Master Data Structures
& Algorithms — Free

The bedrock every advanced algorithm builds on. Begin here regardless of experience level — complexity analysis and basic data structures are the language all DSA speaks.

1. 01Introduction to Algorithms and Complexity
   • What is an algorithm? Properties and classification
   • Time complexity and space complexity
   • Big O notation: O(1), O(log n), O(n), O(n log n), O(n²), O(2ⁿ)
   • Big Theta and Big Omega — tight and lower bounds
   • Best, worst, and average case complexity with examples
   • Amortized analysis and recurrence relations
2. 02Basic Data Structures
   • Arrays: declaration, traversal, insertion, deletion, 2D arrays
   • Strings: manipulation, substring, reversal, palindrome checks
   • Singly linked list: insert, delete, traverse, reverse
   • Doubly linked list and circular linked list
   • Stack: LIFO, push, pop, peek — array and linked list implementations
   • Queue: FIFO, enqueue, dequeue — simple, circular, and deque
   • Pointers and memory management recap (C/C++)
3. 03Basic Sorting and Searching
   • Linear search — O(n) sequential scan
   • Binary search — O(log n), iterative and recursive
   • Bubble sort, selection sort, insertion sort
   • Sorting stability and in-place vs out-of-place sorting
   • Ternary search and exponential search

Trees, heaps, graphs, and the algorithms that operate on them — the most interview-tested data structures in computer science.

4. 04Trees and Heaps
   • Binary tree: properties, height, depth, diameter
   • Tree traversals: inorder, preorder, postorder, level-order (BFS)
   • Binary Search Tree (BST): insert, search, delete, validation
   • Min-heap and max-heap: heapify, insert, extract-min/max
   • Heap sort using a priority queue
   • Hash tables: hashing, chaining, open addressing, load factor
5. 05Advanced Sorting Algorithms
   • Merge sort: divide and conquer, O(n log n), stable
   • Quick sort: partitioning, Lomuto and Hoare schemes, pivot selection
   • Counting sort, radix sort — linear time sorting
   • Bucket sort and external sorting
   • Comparison-based sorting lower bound: Ω(n log n)
6. 06Graph Algorithms
   • Graph representations: adjacency matrix, adjacency list, edge list
   • DFS — depth-first search: iterative and recursive
   • BFS — breadth-first search and shortest path in unweighted graphs
   • Cycle detection in directed and undirected graphs
   • Dijkstra's algorithm for shortest path in weighted graphs
   • Bellman-Ford and Floyd-Warshall all-pairs shortest paths
   • Minimum Spanning Tree: Kruskal's algorithm and Prim's algorithm
7. 07Recursion and Backtracking
   • Understanding the recursion call stack and recursion tree
   • Tail recursion and memoized recursion
   • Backtracking: state space tree, pruning, and feasibility
   • Classic problems: N-Queens, Sudoku Solver, Word Search
   • Subsets, permutations, and combinations generation
   • Rat in a Maze, Knight's Tour, Hamiltonian Path

Dynamic programming, advanced data structures, and string algorithms — the topics that separate good engineers from great ones. The most heavily tested in FAANG interviews.

8. 08Dynamic Programming
   • Optimal substructure and overlapping subproblems
   • Memoization (top-down DP) vs tabulation (bottom-up DP)
   • Fibonacci, Climbing Stairs, House Robber
   • 0/1 Knapsack and Unbounded Knapsack
   • Longest Common Subsequence (LCS) and Longest Increasing Subsequence (LIS)
   • Coin Change, Edit Distance, Matrix Chain Multiplication
   • DP on trees, DP on graphs, bitmask DP
9. 09Advanced Data Structures
   • Trie (prefix tree): insert, search, prefix queries, autocomplete
   • Segment Tree: range queries, point updates, lazy propagation
   • Binary Indexed Tree (BIT / Fenwick Tree): prefix sums, updates
   • Disjoint Set Union (DSU / Union-Find): union by rank, path compression
   • AVL trees and Red-Black trees: self-balancing BST concepts
   • Sparse Table for range minimum/maximum queries
10. 10Greedy Algorithms
    • Greedy choice property and optimal substructure
    • Greedy vs DP — when each approach applies
    • Activity selection problem and interval scheduling
    • Huffman coding — optimal prefix-free data compression
    • Job scheduling: deadline-based and weighted job scheduling
    • Fractional knapsack, Egyptian fraction, minimum platforms
11. 11String Algorithms
    • Naive pattern matching — O(nm)
    • KMP (Knuth-Morris-Pratt) algorithm — O(n+m) with failure function
    • Rabin-Karp rolling hash algorithm
    • Z-algorithm for pattern matching in O(n)
    • Trie-based string problems: longest prefix, word search
    • Suffix arrays and suffix trees (conceptual)

Bit manipulation, advanced graphs, and competitive programming — the skills that crack the hardest interview problems and win algorithmic competitions.

12. 12Bit Manipulation
    • Bitwise operators: AND, OR, XOR, NOT, left shift, right shift
    • XOR tricks: find unique element, swap without temp, missing number
    • Check, set, clear, and toggle specific bits
    • Count set bits (popcount), Brian Kernighan's algorithm
    • Power of 2, bitmask for subsets, subset sum with bitmask
13. 13Mathematical Algorithms
    • GCD (Euclidean algorithm) and LCM
    • Sieve of Eratosthenes for prime generation
    • Modular arithmetic: addition, multiplication, modular inverse
    • Fast exponentiation (binary exponentiation) in O(log n)
    • Combinatorics: nCr, Pascal's triangle, Catalan numbers
    • Number theory: Euler's totient, CRT, Fermat's little theorem
14. 14Advanced Graph Algorithms
    • Topological sort: Kahn's BFS algorithm and DFS-based approach
    • Strongly Connected Components (SCC): Kosaraju's algorithm
    • Tarjan's SCC and bridge-finding algorithm
    • Network Flow: Ford-Fulkerson and Edmonds-Karp algorithm
    • Bipartite matching and maximum matching
15. 15Problem Solving Paradigms
    • Divide and conquer: Karatsuba multiplication, closest pair of points
    • Sliding window technique for subarray and substring problems
    • Two-pointer technique for sorted array and string problems
    • Randomized algorithms: randomized quick sort, reservoir sampling
    • Approximation algorithms for NP-hard problems
16. 16Competitive Programming
    • Fast I/O in C++: ios_base::sync_with_stdio, cin.tie
    • Online judges: Codeforces, LeetCode, HackerRank, USACO, ICPC
    • Problem classification: recognize DP, greedy, graph, and math problems
    • Time management and contest strategy
    • Debugging and stress testing competitive solutions

For learners pushing into expert territory — topics used in high-level competitive programming and systems research.

17. 17Concurrency and Parallel Algorithms
    • Parallel algorithm design: work and span model
    • Concurrent data structures: lock-free queue, CAS operations
    • Parallel prefix sum, parallel merge sort
18. 18Advanced Expert Topics
    • Persistent data structures — version control for data structures
    • Suffix automaton for efficient string processing
    • Heavy-Light Decomposition (HLD) for tree queries
    • Centroid decomposition for tree path queries
    • Link-Cut Trees and offline dynamic connectivity