### CHFI v8 - Computer Hacking Forensic Investigator

312-49-v8

Explore computer algorithms for solving real-world problems using Python and C# programming language.

(ESS-ALGO.AE1) / ISBN : 978-1-64459-270-0This course includes

Interactive Lessons

Gamified TestPrep

Lab

AI Tutor (Add-on)

15
Reviews

This course is about solving real-world problems following the principles of computer algorithms using Python and C# languages. Learn the fundamentals of Python algorithms (step-by-step instructions for solving problems) and data structures (organizing, storing, and accessing data). Explore a wide range of structures including arrays, linked lists, stacks, and queues. Learn how to measure an algorithm's most crucial complexities including how long it takes to run (time) and how much space it uses (space/memory). The course includes exercises and solutions that are useful for both students and professionals. It aims to help you prepare for programming job interviews that typically involve technical algorithm questions.

- Create algorithms to solve computational problems.
- Implementing data structures for storing and accessing data
- Expertly handling sorting algorithms like sort, merge sort, quicksort, and binary search
- Determining algorithm’s space and time complexities
- Learning advanced algorithms techniques like recursion, backtracking, and divide & conquer
- Gain confidence to answer computer algorithm related technical questions during job interviews
- Enhance your programming skills in both Python and C#

21+ Interactive Lessons | 168+ Quizzes | 434+ Flashcards | 436+ Glossary of terms

60+ Pre Assessment Questions | 57+ Post Assessment Questions |

1

- Why You Should Study Algorithms
- Algorithm Selection
- Who This Course Is For
- Getting the Most Out of This Course
- How This Course Is Structured
- What You Need to Use This Course
- Conventions

2

- Approach
- Algorithms and Data Structures
- Pseudocode
- Algorithm Features
- Practical Considerations
- Summary
- Exercises

3

- Randomizing Data
- Finding Greatest Common Divisors
- Performing Exponentiation
- Working with Prime Numbers
- Performing Numerical Integration
- Finding Zeros
- Gaussian Elimination
- Least Squares Fits
- Summary
- Exercises

4

- Basic Concepts
- Singly Linked Lists
- Doubly Linked Lists
- Sorted Linked Lists
- Self-Organizing Linked Lists
- Linked-List Algorithms
- Multithreaded Linked Lists
- Linked Lists with Loops
- Summary
- Exercises

5

- Basic Concepts
- One-Dimensional Arrays
- Nonzero Lower Bounds
- Triangular Arrays
- Sparse Arrays
- Matrices
- Summary
- Exercises

6

- Stacks
- Queues
- Binomial Heaps
- Summary
- Exercises

7

- O(N2) Algorithms
- O(N log N) Algorithms
- Sub O(N log N) Algorithms
- Summary
- Exercises

8

- Linear Search
- Binary Search
- Interpolation Search
- Majority Voting
- Summary
- Exercises

9

- Hash Table Fundamentals
- Chaining
- Open Addressing
- Summary
- Exercises

10

- Basic Algorithms
- Factorial
- Fibonacci Numbers
- Rod-Cutting
- Tower of Hanoi
- Graphical Algorithms
- Koch Curves
- Hilbert Curve
- Sierpiński Curve
- Gaskets
- The Skyline Problem
- Backtracking Algorithms
- Eight Queens Problem
- Knight's Tour
- Selections and Permutations
- Selections with Loops
- Selections with Duplicates
- Selections Without Duplicates
- Permutations with Duplicates
- Permutations Without Duplicates
- Round-Robin Scheduling
- Recursion Removal
- Tail Recursion Removal
- Dynamic Programming
- Bottom-Up Programming
- General Recursion Removal
- Summary
- Exercises

11

- Tree Terminology
- Binary Tree Properties
- Tree Representations
- Tree Traversal
- Sorted Trees
- Lowest Common Ancestors
- Threaded Trees
- Specialized Tree Algorithms
- Interval Trees
- Summary
- Exercises

12

- AVL Trees
- 2-3 Trees
- B-Trees
- Balanced Tree Variations
- Summary
- Exercises

13

- Searching Game Trees
- Searching General Decision Trees
- Swarm Intelligence
- Summary
- Exercises

14

- Network Terminology
- Network Representations
- Traversals
- Strongly Connected Components
- Finding Paths
- Transitivity
- Shortest Path Modifications
- Summary
- Exercises

15

- Topological Sorting
- Cycle Detection
- Map Coloring
- Maximal Flow
- Network Cloning
- Cliques
- Community Detection
- Eulerian Paths and Cycles
- Summary
- Exercises

16

- Matching Parentheses
- Pattern Matching
- String Searching
- Calculating Edit Distance
- Phonetic Algorithms
- Summary
- Exercises

17

- Terminology
- Transposition Ciphers
- Substitution Ciphers
- Block Ciphers
- Public-Key Encryption and RSA
- Other Uses for Cryptography
- Summary
- Exercises

18

- Notation
- Complexity Classes
- Reductions
- 3SAT
- Bipartite Matching
- NP-Hardness
- Detection, Reporting, and Optimization Problems
- Detection ≤p Reporting
- Reporting ≤p Optimization
- Reporting ≤p Detection
- Optimization ≤p Reporting
- Approximate Optimization
- NP-Complete Problems
- Summary
- Exercises

19

- Types of Parallelism
- Distributed Algorithms
- Summary
- Exercises

20

- Asking Interview Puzzle Questions
- Answering Interview Puzzle Questions
- Summary
- Exercises

A

- Lesson 1: Algorithm Basics
- Lesson 2: Numeric Algorithms
- Lesson 3: Linked Lists
- Lesson 4: Arrays
- Lesson 5: Stacks and Queues
- Lesson 6: Sorting
- Lesson 7: Searching
- Lesson 8: Hash Tables
- Lesson 9: Recursion
- Lesson 10: Trees
- Lesson 11: Balanced Trees
- Lesson 12: Decision Trees
- Lesson 13: Basic Network Algorithms
- Lesson 14: More Network Algorithms
- Lesson 15: String Algorithms
- Lesson 16: Cryptography
- Lesson 17: Complexity Theory
- Lesson 18: Distributed Algorithms
- Lesson 19: Interview Puzzles

- Discussing about Algorithms, Numerical Algorithms, and Arrays
- Learning Common Run Time Functions
- Understating about Big O Notation

- Creating Pseudorandom Numbers
- Making Random Walks
- Calculating Greatest Common Divisors
- Testing of Primality
- Performing Numerical Integration
- Using Back Substitution

- Finding Cells

- Discussing about Arrays, Stacks and Queues, and Sorting
- Finding Median
- Finding Average
- Learning about Array Types
- Adding Matrices

- Reversing An Array
- Understanding Stacks
- Understanding Queues
- Merging Trees
- Understanding Binomial Trees

- Understanding the Heap Sort Algorithm
- Understanding Sorting Algorithm
- Summarizing the Algorithms

- Understanding the Linear Search Algorithm
- Understanding Binary Search
- Understanding Interpolation Search
- Discussing about Searching, Hash Tables, and Recursion

- Understanding Open Addressing

- Understanding the Factorial
- Learning about the Koch Curves
- Understanding Eight Queens Problem

- Understanding about Balanced and Decision Trees
- Understanding Tree Terminology
- Calculating Number of Nodes
- Learning About Tree Traversal

- Deleting Values

- Understanding Random Search

- Understanding Network Terminology

- Using the Brute Force Approach

- Understanding Pattern Matching
- Discussing about Network and String Algorithms

- Calculating the Euler's Totient Function

- Discussing about Cryptography, Complexity Theory, and Distributed Algorithms

Check out the FAQs

Still have unanswered questions and need to get in touch?

Contact Us NowYes, you’ll be learning both the programming languages.