Click any module to expand. Module 2 (Problem-Solving Techniques) is the most important addition — the mental frameworks that turn data structure knowledge into interview problem-solving ability. Without techniques, knowing "what a tree is" doesn't help you solve tree problems under pressure.
How to measure algorithm efficiency and the math that underpins DSA
Formal definitions of asymptotic bounds. Analysing worst-case (O), average-case (Θ), and best-case (Ω). Common complexities: O(1), O(log n), O(n), O(n log n), O(n²), O(2ⁿ). How to determine complexity from code by counting loops and recursive calls.
Measuring memory usage: input space vs auxiliary space. Stack space in recursion (O(depth)). In-place vs out-of-place algorithms. Trade-offs: time-space trade-off decisions that interviewers test.
Recursive thinking: base case + recursive case. Call stack visualisation. Recurrence relations: T(n) = 2T(n/2) + O(n). Master theorem for solving recurrences. Tail recursion and optimisation. Stack overflow and how to avoid it.
GCD (Euclidean algorithm), LCM, modular arithmetic, fast exponentiation (binary exponentiation). Sieve of Eratosthenes for primes. Combinatorics basics (nCr, nPr). Catalan numbers. Bit representation of integers. Why math matters for DP, number theory problems, and competitive coding.
AND, OR, XOR, NOT, left/right shifts. Check if bit is set, set/clear/toggle a bit. Count set bits (Brian Kernighan's algorithm). Check power of 2. XOR tricks: find single number, swap without temp. Bitmask for subsets. Interview favourite at Google, Amazon, DE Shaw.
The mental frameworks that turn knowledge into interview performance — the most important module
Two pointers moving inward (pair sum in sorted array), outward (expand around centre for palindromes), or same direction (slow/fast for cycle detection). Container with most water, 3Sum, remove duplicates in-place. The most versatile O(n) technique for array/string problems.
Fixed-size window (max sum subarray of size k) and variable-size window (smallest subarray with sum ≥ target, longest substring without repeating characters). Template pattern: expand right, shrink left when condition breaks. Converts O(n²) brute force to O(n).
Beyond searching arrays — binary search on the ANSWER space. "What's the minimum capacity to ship packages in D days?" "Find the smallest divisor given a threshold." Recognising when a problem has monotonic feasibility. Template: lo, hi, check(mid).
Split problem into subproblems, solve recursively, combine results. Merge sort (classic D&C), count inversions, closest pair of points, maximum subarray (Kadane vs D&C). Recognising when a problem splits cleanly into independent halves.
Prefix sum for O(1) range queries. 2D prefix sums for submatrix queries. Difference arrays for range update operations. Kadane's algorithm as a prefix sum variant. Applications: subarray sum equals k, equilibrium index.
Hash maps for O(1) lookup. Frequency counting. Two-sum pattern (complement lookup). Group anagrams. Subarray sum patterns. Hash sets for duplicate detection. When hashing beats sorting — and when it doesn't (worst-case O(n) collision).
Merge overlapping intervals, insert interval, meeting rooms (can attend all? minimum rooms needed). Sweep line algorithm for interval scheduling. Sorting by start/end time. Greedy interval selection. Problems companies love: merge intervals, non-overlapping intervals.
DFS/BFS on 2D grids. Number of islands, flood fill, shortest path in binary matrix, rotting oranges. Direction vectors (dx[], dy[]). When to use DFS vs BFS on grids. Boundary conditions and visited tracking. One of the most asked problem categories at Amazon.
The 5-step framework: (1) Understand — restate, examples, edge cases. (2) Classify — which pattern does this match? (3) Plan — pseudocode before coding. (4) Code — clean, modular, named variables. (5) Test — trace through examples, check edge cases. Thinking aloud in interviews. Managing time when stuck.
The most tested data structures — 40%+ of all coding interview problems involve arrays or strings
Insertion, deletion, searching in unsorted and sorted arrays. Rotation (left, right, by k positions). Dutch National Flag problem (3-way partition). Next permutation. Maximum subarray sum (Kadane's). Stock buy/sell variants.
Matrix traversal: row-major, column-major, diagonal, spiral order. Matrix rotation (90°, 180°). Transpose. Search in sorted matrix (row-wise + column-wise sorted). Set matrix zeroes. The matrix is a grid — DFS/BFS apply here too.
Reversal, palindrome checking, anagram detection & grouping. Longest palindromic substring (expand around centre + Manacher's). String to integer (atoi). String compression. Rabin-Karp hashing for pattern matching.
KMP algorithm (failure function + O(n+m) matching). Z-algorithm. Rabin-Karp (rolling hash). When to use which: KMP for single pattern, Rabin-Karp for multiple patterns. Suffix arrays and suffix trees (conceptual).
Linear data structures for dynamic data and LIFO/FIFO processing
Node structure, insertion (head, tail, middle), deletion, search. Reverse a linked list (iterative + recursive — the #1 linked list question). Merge two sorted lists. Find middle element (slow/fast pointers). Remove nth from end.
Detect and find cycle entry (Floyd's algorithm). Palindrome linked list. Intersection of two lists. Flatten a multilevel linked list. LRU Cache implementation (HashMap + Doubly Linked List). Deep copy with random pointers.
Stack implementation (array, linked list). Valid parentheses. Evaluate postfix/prefix expressions. Implement queue using stacks. Min stack (O(1) getMin). Largest rectangle in histogram. Daily temperatures.
Next greater element (left, right, circular). Stock span problem. Trapping rain water. Sliding window maximum (monotonic deque). When to use monotonic structures — recognising the "maintain order" pattern.
Queue implementation. Circular queue. Priority of operations (BFS uses queue, DFS uses stack). Deque — O(1) operations at both ends. Implementing stack using queue. Design a circular buffer.
Finding and ordering data — foundational algorithms with wide application
Classic binary search. First/last occurrence. Search in rotated sorted array. Peak element. Square root (integer). Binary search on answer (covered in Module 2 — applied here). lower_bound/upper_bound (STL).
Bubble, Selection, Insertion (stable, O(n²)). Merge Sort (stable, O(n log n), extra space). Quick Sort (in-place, O(n log n) average, pivot strategies). Heap Sort (in-place, O(n log n)). Stability and when it matters.
Counting Sort, Radix Sort, Bucket Sort — O(n) when constraints allow. When non-comparison sorting beats quicksort. Quickselect for kth smallest/largest (O(n) average). Dutch National Flag (3-way partition for repeated elements).
Merge sort for count inversions. Custom comparators for sorting objects. Sorting + two pointers (3Sum, 4Sum). Sorting intervals by start/end time. When to sort first vs when to use hash maps.
Hierarchical data structures — the backbone of advanced DSA
Node structure, tree terminology (root, leaf, height, depth, level). Full, complete, perfect, balanced binary trees. Maximum nodes at level k, maximum nodes in tree of height h. Tree construction from traversals.
DFS traversals: inorder (left-root-right), preorder (root-left-right), postorder (left-right-root). BFS: level-order traversal. Iterative traversal using stack (Morris traversal for O(1) space). Zigzag level-order. Vertical order traversal.
Height/depth, diameter, check balanced, mirror/symmetric tree, path sum, LCA (Lowest Common Ancestor), serialize/deserialize, maximum path sum, right side view, flatten to linked list. These are the 15 most asked tree problems.
BST property (left < root < right). Search, insert, delete in BST. Inorder traversal gives sorted order. Validate BST. Kth smallest element. Floor/ceiling in BST. Construct BST from preorder/sorted array.
AVL trees (rotations: LL, RR, LR, RL). Red-black tree concepts (used internally by set/map in C++, TreeMap in Java). B-trees (conceptual — database indexing). Why self-balancing matters: O(log n) guaranteed vs O(n) worst case.
Efficient access to min/max and O(1) lookup — enabling top-K and frequency patterns
Complete binary tree property. Heapify (sift-up, sift-down). Build heap in O(n). Insert and extract in O(log n). Heap sort. Priority queue implementation. Min-heap vs max-heap — when to use which.
Kth largest/smallest element. Top K frequent elements. Sort a nearly sorted array (k-sorted). Merge K sorted lists/arrays. Median of a stream (two heaps). Smallest range covering K lists. The "use opposite heap" trick.
Hash function design. Open addressing (linear probing, quadratic probing). Separate chaining. Load factor and resizing. How HashMap works internally in Java (buckets, linked list → tree in Java 8). Time complexity analysis: average O(1), worst O(n).
Two-sum family. Group anagrams. Subarray sum equals K (prefix sum + hash). Longest consecutive sequence. First non-repeating character. LRU Cache (hash + linked list). Count distinct elements in window.
Modelling relationships, networks, and dependencies — the most complex DSA topic
Adjacency list vs adjacency matrix — when to use which. BFS (level-by-level, shortest path in unweighted graphs). DFS (explore-deep-first, stack-based). Connected components. Bipartite graph check (BFS 2-colouring).
Cycle detection in undirected graphs (DFS parent tracking, Union-Find). Cycle detection in directed graphs (DFS colouring: white-grey-black). Topological sort: Kahn's algorithm (BFS, in-degree) and DFS-based. Applications: course schedule, build order.
Dijkstra's (non-negative weights, priority queue). Bellman-Ford (handles negative weights, detects negative cycles). Floyd-Warshall (all-pairs shortest path, O(V³)). 0-1 BFS (deque-based for 0/1 weights). When to use which algorithm.
Kruskal's algorithm (sort edges + Union-Find). Prim's algorithm (priority queue + greedy). MST properties. Applications: network design, clustering. Why understanding MST matters beyond the algorithm itself.
Union by rank, path compression — near O(1) amortised. Connected components. Cycle detection in undirected graphs. Kruskal's MST. Number of islands (Union-Find approach). Redundant connection. A crucial data structure for graph problems.
Strongly connected components (Kosaraju's, Tarjan's). Articulation points and bridges. Euler path/circuit. Graph colouring. Word ladder (BFS on transformed words). Clone graph. Alien dictionary (topological sort on characters).
The most feared interview topic — demystified through patterns, not memorisation
Overlapping subproblems + optimal substructure — the two conditions for DP. Top-down (recursion + memo) vs bottom-up (iteration + table). State definition: what does dp[i] represent? Transition: how to compute dp[i] from previous states. Space optimisation (rolling arrays).
Climbing stairs, house robber, decode ways, word break, coin change (min coins), jump game, maximum product subarray. The "choose or skip" pattern. The "take or not take" pattern. Fibonacci-style recurrence.
Longest Common Subsequence (LCS), Longest Common Substring, Edit Distance, 0/1 Knapsack, Unbounded Knapsack, Minimum Path Sum in grid, Unique Paths. Two-string comparison DP — the most common 2D pattern.
Longest Increasing Subsequence (LIS — O(n log n) with binary search). Longest Palindromic Subsequence. Palindrome Partitioning. Matrix Chain Multiplication. Partition Equal Subset Sum. Target Sum. Interval DP patterns.
Diameter of tree (DP on tree). House robber III (DP on tree nodes). Longest path in DAG. Number of paths in grid with obstacles. DP with topological ordering in DAGs.
DP with bitmask for subset enumeration. Travelling Salesman Problem (TSP). Assignment problem. Digit DP (counting numbers with specific properties). Profile DP. When state space is too large — how to identify and prune.
Tries, segment trees, and the patterns that win contests and crack hard interview problems
Insert, search, startsWith operations. Autocomplete system. Word search in a matrix (Trie + DFS). Longest common prefix. Maximum XOR of two numbers (bitwise trie). Count distinct substrings. Trie vs HashMap for string problems.
Build, query, and update in O(log n). Range sum, range min/max queries. Lazy propagation for range updates. When segment tree is needed vs when prefix sums suffice. Merge sort tree (conceptual).
Point update + prefix query in O(log n). Simpler to implement than segment tree. Range sum queries. Count of inversions using BIT. When to use BIT vs segment tree (BIT is simpler but less flexible).
N-Queens, Sudoku solver, permutations, combinations, subsets, word search, combination sum, palindrome partitioning. The backtracking template: choose → explore → unchoose. Pruning strategies to reduce search space.
Activity selection, fractional knapsack, job sequencing, Huffman encoding, minimum platforms. Greedy choice property — proving correctness. When greedy works vs when DP is needed. Exchange argument for proof.
Across all topics — easy, medium, hard. Tracked on the coding platform with topic-wise breakdowns.
Weekly 3-problem contests in 60–90 minutes — mimicking real placement coding rounds.
Practice problems tagged by which company asked them — Google, Amazon, TCS, Infosys patterns.
Given a problem, identify the technique (two pointers? sliding window? DP?) within 2 minutes — before coding.
Verbalise your approach before coding — the skill that interviewers evaluate as much as the code itself.
After every solution: "Time: O(?), Space: O(?)" — stated before the interviewer asks.
Trainers don't just explain data structures — they solve problems live, thinking aloud, showing the decision-making process. 4–5 sessions per week, each focused on a technique or topic.
2,500+ problems on our platform, tagged by topic, difficulty, and company. Students solve 3–5 problems daily between sessions. The platform tracks speed, accuracy, and attempt count.
3 problems in 60 minutes, every week. Mimics placement coding rounds. Leaderboard creates healthy competition. Contest review session follows — analysing approaches and optimal solutions.
Student-wise dashboards showing: problems solved by topic, accuracy rates, time per problem, weak areas. TPOs see batch-level DSA readiness. AI recommends which topics to focus on next.
Google, Amazon, Microsoft, Flipkart, DE Shaw, Goldman Sachs — the coding round IS the interview. 2–3 DSA problems in 60 minutes. Without systematic DSA training, students cannot compete. There is no shortcut.
TCS Digital, Infosys SP, Cognizant GenC Next, Wipro Turbo — the premium hiring tracks at service companies now include DSA-level coding rounds. Students who only prepare aptitude miss these higher-package opportunities.
Knowing "what a graph is" doesn't help you solve "find shortest path in a grid with obstacles." Knowing the BFS-on-grid technique does. Module 2 (Problem-Solving Techniques) is what converts knowledge into interview performance.
A student who's solved 200+ DSA problems recognises patterns within seconds. A student who's solved 20 problems spends the first 10 minutes figuring out the approach — and runs out of time. There is no substitute for practice volume.
E-305, Industrial Area, Sahibzada Ajit Singh Nagar, Punjab 160055, IN
