When I started learning algorithms, the hardest part was not any single topic. It was knowing what to study next. This page is the order I would follow if I were starting again, with a short note on each topic and links to the tutorials, solved problems and MCQ sets on CodingHumans that go with it.
You do not need to finish one section perfectly before moving on. Read the note, solve two or three problems, try the MCQs, and come back later. Most of this clicks on the second pass.
1. Analysis of algorithms
Before comparing algorithms, you need a way to measure them. Big-O notation describes how the running time or memory grows as the input grows. An O(n) loop over a million items is fine; an O(n²) pair of nested loops over the same input is a trillion steps and will time out on any judge.
- Analysis of Algorithms: time and space complexity, best, worst and average case
- Running Time and Complexity (HackerRank Day 25): checking primes in O(√n)
- Algorithms MCQs: Asymptotic Analysis, Recurrences and Divide and Conquer
| Complexity | Example | Rough limit for n in 1 second |
|---|---|---|
| O(log n) | Binary search | Practically any n |
| O(n) | Linear search, one pass over an array | About 108 |
| O(n log n) | Merge sort, heap sort | About 106 to 107 |
| O(n²) | Bubble sort, checking all pairs | About 104 |
| O(2n) | Trying every subset | About 25 |
2. Searching
Linear search checks items one by one and works on any list. Binary search halves the range at every step, so it needs only about 20 comparisons for a million items, but the data must be sorted first. Binary search also shows up in places you would not expect, such as finding the smallest speed or capacity that satisfies a condition.
- Linear (sequential) search
- Binary search, and binary search on the answer
- Data Structures MCQs: Sorting and Searching
3. Sorting
Learn bubble, selection and insertion sort to understand the idea of swapping and shifting, then spend real time on merge sort and quick sort, because they teach divide and conquer. In practice you will call the library sort (Arrays.sort, std::sort, sorted()), but interviewers still ask how these work, which ones are stable, and why quick sort can fall to O(n²).
- Bubble, selection and insertion sort: O(n²), simple, fine for small inputs
- Merge sort: O(n log n) always, stable, needs extra memory
- Quick sort: O(n log n) on average, in place, worst case O(n²)
- Heap sort and counting sort
- Sorting (HackerRank Day 20): counting swaps in bubble sort
- Kth Largest Element in an Array (LeetCode)
- Algorithms MCQs: Sorting, Searching and Hashing
4. Recursion and divide and conquer
A recursive function solves a problem by calling itself on a smaller version of it. Always write the base case first, then make sure every call moves towards it. Divide and conquer is recursion with a plan: split the input, solve each part, then combine. Merge sort, quick sort and binary search all follow this pattern.
- Tree traversal (inorder, preorder, postorder) in Java
- Finding the maximum node in a binary tree
- Binary Search Trees (HackerRank Day 22): height of a BST
5. Greedy algorithms
A greedy algorithm makes the choice that looks best right now and never goes back. It is fast and simple, but it only works when you can prove that the local best choice leads to the overall best answer. Activity selection, Huffman coding, and Kruskal's and Prim's minimum spanning tree algorithms are the classic examples. Coin change with arbitrary coins is the classic case where greedy fails.
6. Dynamic programming
Dynamic programming is for problems where the same smaller problems come up again and again. Instead of solving them repeatedly, you store each answer the first time. The plain recursive Fibonacci makes about 2n calls; with memoisation it makes n. Start with Fibonacci, climbing stairs and coin change, then move to knapsack and longest common subsequence.
- Finding the Nth Fibonacci number using top-down DP
- Algorithms MCQs: Greedy, Dynamic Programming, Backtracking and NP-Completeness
7. Graph algorithms
Graphs model anything with connections: roads, friends, web pages, task dependencies. Learn to store a graph as an adjacency list, then BFS (shortest path when every edge has the same weight) and DFS (cycles, connected components, topological sort). After that, Dijkstra for weighted shortest paths and Kruskal or Prim for minimum spanning trees.
8. Backtracking
Backtracking builds a solution step by step and undoes a step as soon as it cannot lead anywhere. N-Queens, Sudoku, generating permutations and subset sum are the standard problems. It is still exponential in the worst case, so the skill is in cutting off bad branches early.
Data structures you will need along the way
Algorithms and data structures go together. A good choice of structure often turns a slow solution into a fast one, for example using a hash set to check membership in O(1) instead of scanning a list.
- Arrays
- Linked lists, stacks and queues, with a queue using two stacks and a stack using two queues in C++
- Trees and binary search trees
- Heaps and hashing
How to practise
- After reading a topic, solve problems without looking at the solution for at least 20 to 30 minutes.
- Write down the time and space complexity of every solution you submit. It becomes a habit quickly.
- When you look at a solution, close it and write the code again from memory the next day.
- Use the MCQ sets to check theory before exams like GATE. The GATE CSE algorithms set is a good test once you have covered sections 1 to 6.
For everything else in one place, see the Interview Preparation Hub and the coding problems and solutions hub.
Comments
Post a Comment