It's my first question when I started learning algorithms except for the central question: for what. This article helps you with how, not for what.
After years of studying algorithms and helping others prepare for technical interviews, I've developed a systematic approach that builds solid foundations before tackling complex problems. This complements my guide on solving LeetCode problems.
Basic knowledge
You'll need to start from fundamentals. The base can be learned from several ways: video-course, books, youTube videos. The primary approach for you "understanding depth", not breadth. Focus on one topic and complete it and create a mind-map inside your head. For example, coding interviews require deep knowledge for solving a problem. Also, you need the experience to code quickly and correctly. You only develop these skills focused on topics one by one.
Topics:
- Math. Learn about logarithm, set theories, bitwise operations, combinatorics, and other basic math concepts.
- Basic Data Structures. Learn about array, linked list, binary trees, hash maps, queue, stacks, and other fundamental data structures.
On every topic, you need to think about how to practice. Therefore, you need to analyze a problem in-depth. You have two options for it. The first one: implement every data structure. The second: you can find problems for every data structure on popular sites like LeetCode, HackerRank, CodeSignal, etc. (but not deep dive into algorithms - only think how to practice data structure and math knowledge on simple problems.)
My Learning Path Experience
Phase 1 (Months 1-2): Data Structures I started by implementing each data structure from scratch in JavaScript/Python:
- Arrays and strings: 2 weeks of daily practice
- Hash maps: Deep dive into collision resolution techniques
- Trees: Binary trees, BST, traversal algorithms
- Graphs: Adjacency lists, matrix representation
Phase 2 (Months 3-4): Core Algorithms
Each algorithm required understanding both implementation and use cases:
- Binary search: Master the template and variations
- Sorting: Understanding when quicksort vs mergesort is optimal
- Graph algorithms: BFS/DFS for different problem types
Next Level
Deep dive to algorithms. Learn what big-O and how to analyze algorithms. You can find a lot of information about this topic: articles, courses, youTube videos.
Implement all basic algorithms:
- Euclid's Algorithm,
- Binary Search,
- DFS and BFS,
- Array sorts,
- String manipulation,
- Data Structure traversal,
- Hashing functions
Again, you need to implement all these algorithms and practice all algorithms using the same platform as for the data structure. It's the main idea for practicing.
Rule: how to not forget all these topics?
The best technique I’ve seen - using iteration. Solve the problem again in 3 days. Then in a week. Then in a month. It will become second nature to you.
Concepts
When you learn basic algorithms - you're ready for the next level: algorithm concepts. It's not easy, but you will need to understand if you want to get better at algorithms. Main concepts:
- Greedy algorithms. A greedy algorithm is a simple, intuitive algorithm that is used in optimization problems.
- Divide-and-conquer. How to divide problems and resolve them detached
- Backtracking. How to use recursion for resolving problems
- Dynamic Programming. Solves the problem by breaking it down into smaller sub-problems and storing the solution to each sub-problem so that each sub-problem is only solved once.
Real-World Application
Phase 3 (Months 5-6): Advanced Patterns
- Two pointer technique: Mastered through 50+ array problems
- Trie data structures: Built autocomplete systems from scratch
- Hash map optimization: Solved complex frequency and mapping problems
Recommended Study Schedule
Daily routine that worked for me:
- Morning (1 hour): Theory review and implementation
- Evening (1 hour): Problem solving practice
- Weekend: Deep dive into one advanced topic
Resource progression:
- Weeks 1-4: Focus on implementing basic data structures
- Weeks 5-8: Master fundamental algorithms
- Weeks 9-12: Advanced patterns and optimization techniques
Once you have the foundation, move to practical problem-solving with my LeetCode preparation guide for interview-specific strategies.
Last but not least level (or boss fight!)
This level has two steps. The first one - resolve problems on paper or whiteboard, without IDEA.
Benefits:
- you're planning before writing
- paper and pen(pencil) you can take anywhere
And after all these steps, you'll need to think about mock-interview. A mock interview mirrors an actual interview. It allows you to practice what to say and do during an interview and get feedback.