TRT
Sign in

DSA · track

Data Structures & Algorithms: Topic-Wise & Pattern-Wise Mastery

Complete dual-mode DSA platform (28 topic modules plus a pattern-recognition playbook) from beginner memory models to expert C++, Java, and Python implementations.

Start with “Bits, bytes and number representation”28 modules · 122 lessons ready

Most algorithm courses hand you a list of disconnected recipes to memorize. Under interview or contest pressure, memorization breaks the moment a problem changes one constraint.

This track is organized around two complementary learning modes so you build both deep structural knowledge and fast pattern recognition:

  1. Mode A — Topic-Wise Learning (28 Modules): Progresses in strict prerequisite order from how bytes, pointers, and cache lines live in hardware (Foundations), through recursion, sorting, binary search, trees, heaps, mathematics, and bit manipulation (Core), to graphs, shortest paths, MSTs, DSU, tries, string matching, dynamic programming, and balanced trees (Advanced), and finally amortized proofs, cache-aware layouts, probabilistic structures, lock-free concurrency, range-query trees, Tarjan SCC / network flow / computational geometry, and production storage engines (Expert).
  2. Mode B — Pattern-Wise Learning: Maps recurring problem clues and input constraints directly to reusable algorithmic templates—teaching you why brute force is slow, what invariant allows you to skip work safely, and how to choose between look-alike techniques (such as Two Pointers vs. Sliding Window vs. Prefix Sum + Hash Map, or Ordinary Binary Search vs. Binary Search on the Answer).

Five Goal-Based Learning Roadmaps

Use the table below to follow the exact module sequence for your goal:

Learner ProfilePrerequisitesModule SequenceMastery Milestone
1. Absolute Beginner (From Scratch)Basic variables, loops, and functions in C++, Java, or PythonFoundations 01–06 -> Core 07–12 -> Advanced 13–16Trace every pointer/index update by hand and solve 60 Foundations/Core problems without hints
2. University Student (Semester Exams)Intro programming (CS1)01–02 (Asymptotics) -> 03–06 (Linear DS) -> 07–12 (Sorting/Trees/Heaps/Math) -> 13–21 (Graphs, DP, Greedy, Tries, Balanced Trees)Derive exact recurrences (T(n)), prove greedy exchange and DP optimality, and trace tree rotations
3. Coding Interview PreparationComfort with arrays, maps, and recursion02–06 -> 07–12 -> 13–21 (Pattern recognition, DP, graphs, tries, and balanced trees)Disambiguate any unseen problem's pattern in under 3 minutes and implement clean C++/Java/Python code in under 25 minutes
4. Competitive ProgrammingSolid Core + Advanced fundamentals12 (Math/Bitmasks) -> 13–21 -> 22, 26, 28 (Segment Trees, Lazy Prop, Fenwick, Tarjan SCC, Dinic Max Flow, Z-Algorithm, Convex Hull)Solve problems with N <= 2 * 10^5 in O(N log N) and bitmask/flow/geometry problems under strict time limits
5. Systems & Advanced Algorithm StudyCore & Advanced DSA20 (AVL/RB/B-Trees) -> 22–28 (Amortized Potential, Cache-Aware Layouts, Bloom/HLL, Lock-Free CAS/ABA, Postgres/RocksDB Internals)Design cache-aligned, thread-safe, and disk-aware data structures verified with hardware performance counters
  1. Level 1Free

    Foundations

    The core ideas, assuming nothing

    1. 01How data lives in memory
    2. 02Measuring cost: Big-O
    3. 03Arrays and strings
    4. 04Linked lists
    5. 05Hash tables
    6. 06Stacks and queues
    Level projectsMemory-level dynamic array, ring-buffer queue, and open-addressed hash table with explicit load-factor invariants in C++, Java, and Python.
  2. Level 2Pro — members only

    Core

    What most real code and most interviews need

    1. 07Recursion and the call stack
    2. 08Sorting
    3. 09Binary search and search spaces
    4. 10Trees and binary search trees
    5. 11Heaps and priority queues
    6. 12Mathematics for DSA & Bit Manipulation
    Level projectsComplete sorting, binary-search-on-answer, BST/heap priority scheduler, and modular number-theory + bit-manipulation toolkit.
  3. Level 3Pro — members only

    Advanced

    Problems that need proof, optimization and trade-offs

    1. 13Graphs
    2. 14Patterns: two pointers, sliding window, prefix sums
    3. 15Dynamic programming
    4. 16Greedy algorithms
    5. 17Shortest paths
    6. 18Union-find and spanning trees
    7. 19Tries and string algorithms
    8. 20Balanced trees
    9. 21Pattern-Wise Problem Solving & Disambiguation Playbook
    Level projectsPattern-recognition engine covering graph shortest paths, DSU, tries, KMP, DP state machines, and the 28-pattern decision matrix.
  4. Level 4Pro — members only

    Expert

    Behavior on real hardware and inside real systems

    1. 22Amortized and probabilistic analysis
    2. 23Cache-aware data structures
    3. 24Probabilistic structures
    4. 25Concurrent data structures
    5. 26Range queries
    6. 27Inside real systems
    7. 28Advanced Graphs, String Matching & Computational Geometry
    Level projectsCache-aware B+ tree / LSM analyzer, lock-free ring buffer, lazy segment tree, Tarjan SCC / Dinic max-flow, and convex hull solver.