# Algorithms and Data Structures

✨ Level | 🕗 Duration | 💻 Practice |

Intermediate | 4-8 months | 400+ coding exercises |

Welcome to a comprehensive course on Algorithms and Data Structures. Completing this course might take more than 6 months. Yet, by the end of the course, you’ll have enough knowledge to ace interviews at top tech companies like Google, Meta, Amazon, etc. The course starts from the basics of algorithms and data structures and dives deep into the most popular topics in the field.

This course is designed for people who already have some background in some general-purpose programming language (like Python, C++, Java, C#), and would like to dive deep into the world of algorithms and data structures.

Large tech companies like Google, Meta, Netflix, and Amazon conduct their interviews checking for deep knowledge of data structures and algorithms. Completing this course will make sure you can ace those interviews and get a job at top tech companies. Salaries for entry-level software engineers at these companies range between $100k and $250k per year.

Freelance platforms like Toptal or Turing require their applicants to be fluent in Data Structures and Algorithms. So, their screening processes include several interviews focusing on algorithmic knowledge.

Software engineers working on platforms like Toptal and Turing earn $50-$90 per hour, while most of the jobs are full-time.

🗯️ Outcomes

By the end of this course, you’ll know how to use various popular data structures to write efficient algorithms that would perform an order of magnitude faster than naive solutions. We will cover best practices for writing code for algorithms and how to prepare for algorithmic interviews. You will work with different algorithms and will implement their variations in various problems to actually master each of those. Most importantly, you will solve many challenging problems that appear in interviews in companies like Google, Microsoft, Amazon, or Meta (previously Facebook).

💻 Learn By Doing

The goal of learning algorithms isn’t just learning the theory.
The goal is to become a problem solver.

In this course, you

**learn by doing**! Each concept has several interactive challenges that you will solve to pass on to the next one. In fact, there are more than 400 practical coding problems in this course. We believe that hands-on learning is the best way to get in-depth knowledge. Here you will have many challenging and at the same time interesting exercises to practice each and every concept that is covered. ⚡ Study At Your Own Pace

You can go hard and complete several levels in one week, or take it slow and focus on each concept for longer. You get to decide the pace that works for you. The only requirement to successfully finish the course is

**consistency**. Practicing 1 or 2 hours every day has tremendously higher returns than practicing once a week for several hours.To make sure you don’t get stuck, there is a

**forum to ask questions**. You can ask questions or help others by answering theirs under each challenge. 🎓 Curriculum

This course focuses on the core concepts of Data Structures and Algorithms and introduces each of them in an intuitive manner. To make the process more fun and engaging, the concepts are organized into levels, and passing each level means you’ve mastered a new concept. These are the main things we will be covering here:

## Implementation problems

- The algorithm is stated right in the problem

- Work with basic data structures like arrays, dictionaries, sets, etc.

## Bitwise operations

- The binary representation of numbers (int → bin, bin → int conversions)

- Negative numbers in binary

- Bitwise operations OR, AND, XOR

- base-k representation (base-10 → base-k, base-k → base-10)

## Prefix sums

- 1D Prefix sum

- 2D Prefix sum

## Sliding window / Two pointers

- Sliding window to find the sum

- Sliding window to find unique values

## Number theory

- Primality check - ,

- Sieve of Eratosthenes

- Prime factorization

- Greatest Common divisor (GCD) and Least common multiple (LCM)

- Modular arithmetic

## Binary Search

- Linear Search VS Binary Search

- Finding a value in a sorted array with a binary search

- Finding a floating-point number with precision

- Including the left endpoint VS including the right endpoint in the answer

- Binary search the answer

## Sorting

- Bogosort

- Selection sort

- Insertion sort

- Bubble sort

## Greedy Algorithms

- Follow a greedy strategy

- Greedy heuristics

## Dynamic Programming

- 1D Dynamic programming (Fibonacci, etc)

- Coin change (min coins)

- Coin change (number of ways)

## Recursion

- Branching factors

- Gray code

- Towers of Hanoi

- Recursive division of a problem into subproblems

## Divide & Conquer & Advanced Sorting

- Merge sort

- Quick sort

- In-place sorting

- The complexity of a comparison-based sorting is always ≥

## Linked List

- Nodes and links

- Traversal and search

- Delete and insert operations

## Queue & Stack

- Insertion and pop order

- Optimizing search with a stack

## Binary Tree & Binary Search Tree (BST)

- Construction of a binary tree

- Searching in a binary tree

- Update and delete elements from a tree

## Heap

## Hashing

- Hashing functions

- Collisions

## Advanced Dynamic Programming

- Edit Distance

- Knapsack problem

- Longest Increasing Subsequence

- Efficient multiplication of
`n`

matrices

## Graph Representations

- Adjacency matrix

- Adjacency list

- Edge list

- Degrees of vertices

## Breadth-First Search (BFS)

- BFS on graphs

- Finding the shortest path

- BFS on a grid

- BFS on other structures

## Depth-First Search (DFS)

- Connectedness

- Cycles

- Topological sort

- Bipartidness

## Trie

- String searching

## Dijkstra

- Finding the shortest path in a weighted graph

- Tricks to use in different problems to simplify and improve the running time of a program

## Backtracking

- N Queens

- Graph coloring

- Filling out grids with values

## Segment Tree

- Basic segment tree - construct, get, update

- Range queries and value updates

- Binary search on a prefix

- Store multiple values in a node

- Preprocess the input and then use a segment tree

## Algorithm Complexity

- Big notation formalized

- P vs NP

🚀 Welcome

Learning is 80% individual work. Completing this course will be your accomplishment and we’re here to support that journey!