Topic:

Math
Array
Searching
Sorting
Matrix
String
Hashing
Bit Masking
Linked List
Stack
Queue
Heap
Binary Tree
BST
Graph
Trie
Greedy
DP
Recursion
Back-Tracking
Algorithms
Design

-----------------------------------------------------------------------------------
---

Sub-Topics:

Math
Prime Numbers (Sieve of Eratosthenes, GCD/LCM)
Modular Arithmetic (Modular Exponentiation, Modular Inverse)
Combinatorics (Permutations, Combinations)
Number Theory (Divisors, Euclid's Algorithm)
Binary Exponentiation
Fibonacci Numbers (Matrix Exponentiation)
Probability and Pigeonhole Principle

Array
Two Pointers Technique
Sliding Window
Prefix Sum and Difference Array
Kadane’s Algorithm (Maximum Subarray Sum)
Subarray Problems (Longest Subarray with Given Sum, Product)
Dutch National Flag Algorithm (3-way Partitioning)
Merge Intervals

Searching
Binary Search (Classic Problems: First and Last Occurrence, Rotated Sorted Array,
Peak Element)
Ternary Search
Searching in 2D Matrices
Exponential Search
Applications of Binary Search (Search Space Problems, e.g., Allocate Books,
Aggressive Cows)

Sorting
Basic Sorting Algorithms (Bubble, Selection, Insertion, Merge, Quick)
Counting Sort, Bucket Sort, Radix Sort
Sorting by Comparator
Stable vs. Unstable Sorting
Inversion Count (Using Merge Sort)
External Sorting (Handling Large Data)

Matrix
Traversals (Spiral, Zigzag, Boundary Traversal)
Search in Sorted Matrix
Rotate Matrix (90° or 180°)
Transpose of a Matrix
Shortest Path Problems (Floyd-Warshall, Dijkstra's on Matrix)
Dynamic Programming in Matrix (Path Problems, Maximum Square)

String
Pattern Matching (KMP, Rabin-Karp, Z Algorithm)
Longest Palindromic Substring
String Hashing
Anagram Problems
Subsequence Problems (Longest Common Subsequence, Edit Distance)
String Compression (Run Length Encoding)
Lexicographical Order Problems

Hashing
Hash Maps and Hash Sets
Count Frequencies
Sliding Window with Hashing (Longest Substring with K Unique Characters)
Handling Collisions in Hashing (Chaining, Open Addressing)
Custom Hash Functions
Hashing Applications (Two Sum, Subarray Sum Equals K)

Bit Masking
Bit Manipulation Basics (Set, Unset, Toggle, Check Bits)
Unique Numbers in Array (XOR Properties)
Power of Two Checks
Subset Generation (Using Bits)
Counting Set Bits (Brian Kernighan’s Algorithm, Lookup Table)
Applications in Dynamic Programming (Traveling Salesman Problem, State Compression)

Linked List
Single and Doubly Linked List Operations
Reverse Linked List (Iterative, Recursive)
Detect and Remove Loop in Linked List
Merge Two Sorted Linked Lists
Copy List with Random Pointer
Flatten Multilevel Linked List
Intersection of Two Linked Lists

Stack
Basic Operations (Push, Pop, Min/Max Stack)
Expression Evaluation (Infix, Postfix, Prefix)
Next Greater/Smaller Element
Stock Span Problem
Valid Parentheses and Variants
Largest Rectangle in Histogram

Queue
Basic Operations (Enqueue, Dequeue)
Circular Queue
Sliding Window Maximum (Deque)
First Non-Repeating Character in Stream
Implementing Stack using Queues (and vice versa)
Priority Queue (Min/Max Heap Basics)

Heap
Min/Max Heap Operations
Kth Largest/Smallest Element
Median of a Stream
Merge K Sorted Arrays
Top K Frequent Elements
Heapify and Build Heap
Applications in Dijkstra's Algorithm, Huffman Encoding

Binary Tree
Traversals (Inorder, Preorder, Postorder, Level Order)
Height, Diameter of a Tree
Lowest Common Ancestor (Binary Tree)
Serialize and Deserialize Tree
Zigzag Level Order Traversal
Path Sum Problems
Binary Tree to Doubly Linked List Conversion

BST (Binary Search Tree)

Graph
Representations (Adjacency List/Matrix)
BFS and DFS (Applications: Connected Components, Cycle Detection)
Shortest Path Algorithms (Dijkstra’s, Bellman-Ford, Floyd-Warshall)
Minimum Spanning Tree (Prim’s, Kruskal’s)
Topological Sort
Bipartite Graph Check
Strongly Connected Components (Kosaraju’s Algorithm)
Disjoint Set Union (Union-Find, Path Compression, Rank)

Trie
Insert and Search Operations
Prefix Matching
Longest Common Prefix
Word Break Problem
Auto-complete System
Count Distinct Substrings (using Trie)

Greedy
Activity Selection Problem
Huffman Encoding
Fractional Knapsack
Job Scheduling Problem
Minimum Platforms
Optimal Merge Pattern
Greedy for Graphs (Prim’s, Kruskal’s)

Dynamic Programming (DP)

Recursion
Basics of Recursion (Factorial, Fibonacci, Tower of Hanoi)
Subset/Permutation/Combination Generation
Backtracking Problems (N-Queens, Sudoku Solver)
Recursive vs Iterative DP

Backtracking
N-Queens Problem
Rat in a Maze
Word Search in Matrix
Subset Sum Problems
All Possible Permutations of a String/Array

Algorithms
Divide and Conquer (Merge Sort, Quick Sort, Binary Search)
Sliding Window Algorithm
Two Pointer Algorithm
Fast Fourier Transform (FFT)
Graph Traversal Algorithms
Shortest Path Algorithms (Dijkstra, Bellman-Ford, Floyd-Warshall)

Design
System Design Basics (Scalability, Load Balancing, Caching)
Design Patterns (Singleton, Factory, Observer)
Design Problems (LRU Cache, Rate Limiter)
APIs and Microservices
Databases (Normalization, Indexing, Sharding, Replication)
-----------------------------------------------------------------------------------
------------