Algorithms and Data Structures

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.
notion image
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.
notion image
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.
notion image

🗯️ 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!