LeetCode patterns 90-day roadmap
- NeetCode, Sean Prashad’s LeetCode Patterns, and GitHub study repos have converged on a pattern-first interview plan that breaks practice into reusable algorithm buckets. - The recurring buckets are specific: arrays and hashing, two pointers, sliding window, trees, graphs, heaps, union-find, and one- and two-dimensional dynamic programming. - The shift is away from random grinding toward trackable roadmaps, spaced review, and curated problem sets. (neetcode.io)
Coding interview prep has settled around a simple idea: stop solving random LeetCode problems and start learning patterns you can reuse. (neetcode.io) (educative.io) A pattern is a repeatable way to attack a class of problems, like using two pointers to scan a sorted array or a sliding window to track a substring. Educative’s 2025 guide says interview prep works better when candidates organize practice around these reusable strategies instead of disconnected questions. (educative.io) (leetcode.com) That structure now shows up across the most-used roadmaps. NeetCode’s public roadmap lists Arrays and Hashing, Two Pointers, Binary Search, Sliding Window, Trees, Heap or Priority Queue, Graphs, 1-D Dynamic Programming, Advanced Graphs, and 2-D Dynamic Programming as separate tracks. (neetcode.io) Sean Prashad’s LeetCode Patterns collection makes the same bet in a different format. It groups 178 questions by pattern, difficulty, and company frequency, with examples like Two Sum, Merge Two Sorted Lists, and Climbing Stairs tagged to specific concepts. (seanprashad.com) The point of a 90-day roadmap is not 90 days as a magic number. It is long enough to cycle from basic arrays and strings into trees, graphs, heaps, union-find, and dynamic programming without mixing every topic together on day one. (github.com 1) (github.com 2) That progression also matches how the techniques build on each other. LeetCode’s own sliding-window guide says the method often replaces nested loops with a single pass, cutting common substring and subarray problems from quadratic time toward linear time. (leetcode.com) The same logic applies to two pointers, heaps, and union-find. They are less about memorizing answers than recognizing cues: contiguous range suggests sliding window, repeated minimum or maximum suggests a heap, and connectivity suggests union-find. (repovive.com) (github.com) The resource layer around this has become its own ecosystem. Ashish Prasad’s awesome-leetcode-resources repository has about 16,300 GitHub stars and organizes articles, patterns, curated problem lists, and interview-prep tools in one place. (github.com) Sean Prashad’s GitHub version of leetcode-patterns has about 12,800 stars and states the goal directly: group questions by subtopic so people repeatedly apply common patterns instead of tackling problems at random. (github.com) The practical version of the roadmap is repetitive by design. Beginner plans emphasize Easy-to-Medium arrays, strings, hash maps, two pointers, and sliding window first, then move into linked lists, trees, graphs, backtracking, heaps, and dynamic programming with review built in. (educative.io) (neetcode.io) That is why the most useful LeetCode roadmap in 2026 looks less like a giant checklist and more like a training block. Pick a pattern, solve a small cluster of related problems, time yourself, review misses, and only then move on. (seanprashad.com) (github.com)