Curriculum Pricing

Sign in Get access

Systematic DSA preparation

Curriculum Pricing Sign in Support

© 2026 AlgoPath. All rights reserved.

Curriculum

25 modules · 272 lessons

01

Analysis of algorithms

8 lessons

Space complexity

Omega and Theta notation

Best, worst, and average case

Analyzing recursive algorithms

Amortized analysis

Unlock the full curriculum

Get instant access to all 25 modules, 272+ lessons, and 500+ problems.

Get access — from $7/monthor $29/year

Practical complexity estimation

10 min

02

Mathematics

12 lessons

Counting digits

Sieve of Eratosthenes

Modular arithmetic

Fast exponentiation

Fibonacci numbers

Number of divisors

Sum of divisors

Euler's totient function

Catalan numbers

03

Bit manipulation

9 lessons

Binary representation

Bitwise operators

Common bit tricks

Counting set bits

Bit masks and subsets

Powers of two and bit checks

Common bit patterns

04

Recursion

11 lessons

How recursion works

Factorial and sum

Binary search (recursive)

Generating subsets

Generating permutations

Recursion on nested structures

Tail recursion and stack safety

05

Arrays

18 lessons

Difference Array

Kadane's Algorithm

Dutch National Flag

Merge Intervals

Next Greater Element

Trapping Rainwater

Majority Element

Product of Array Except Self

Container With Most Water

Subarray Problems

Array Techniques — Decision Guide

06

Searching

7 lessons

Binary Search on the Answer

Search in Rotated Sorted Array

Search in 2D Matrix

Finding Minimum and Peak Elements

07

Sorting

10 lessons

The Comparison Model and Sorting Lower Bound

Sorting Algorithm Decision Guide

08

Matrix

6 lessons

Matrix Basics and Memory Layout

Matrix Traversal — BFS and DFS on Grids

Spiral Order Traversal and Generation

Rotate Matrix In Place

Search in a Sorted Matrix

Dynamic Programming on Grids

09

Hashing

8 lessons

Chaining and Open Addressing

Frequency Counting with Hash Maps

The Two-Sum Pattern

Sliding Window with Hash Maps

Rolling Hash and Rabin-Karp

Hash Map Applications

10

Strings

14 lessons

String Comparison and Sorting

Rabin-Karp Algorithm

String Hashing for Substring Comparison

Anagrams and Permutations

Longest Common Subsequence

String DP Patterns

Trie for String Problems

String Algorithms — Summary and Selection Guide

11

Linked list

12 lessons

Linked list basics

Traversal and search

Insertion and deletion

Reverse a linked list

Cycle detection

Find the middle node

Merge two sorted lists

Merge k sorted lists

Doubly linked list

Intersection and reorder

Linked list summary

12

Stack

9 lessons

Valid parentheses

Monotonic stack

Largest rectangle in histogram

Daily temperatures and next-element patterns

Expression evaluation

Stock span problem

13

Queue

7 lessons

Sliding Window Maximum

Task Scheduling

14

Deque

5 lessons

Deque Implementation

Sliding Window Maximum Deep Dive

Monotone Deque Patterns

Palindrome, Rotation, and Design Problems

15

Tree

16 lessons

Tree Basics and Terminology

In-Order Traversal

Pre-Order and Post-Order Traversal

Level-Order Traversal (BFS)

Height, Depth, and Balanced Trees

Diameter of a Binary Tree

Lowest Common Ancestor

Path Sum Problems

Symmetric Tree, Mirror, and Identical Trees

Tree Construction from Traversals

Serialize and Deserialize Binary Tree

Boundary Traversal, Top View, and Bottom View

Views of a Binary Tree

Distance Problems on Trees

Dynamic Programming on Trees

Tree Module Summary

16

Binary search tree

10 lessons

BST Basics and Properties

Searching in a BST and Validating a BST

Insertion in a BST

Deletion in a BST

In-Order Successor and Predecessor

Kth Smallest and Largest in BST

BST Conversions and Merging

Self-Balancing BSTs — AVL and Red-Black Trees

BST Applications and Advanced Problems

17

Heap

8 lessons

Heap Operations

Heap Implementation

Heapify and Heap Sort

K Largest Elements Problems

Median of a Stream

Merge K Sorted Lists

Heap Applications

18

Graph

15 lessons

Graph Representation

Breadth-First Search

Depth-First Search

Topological Sort

Connected Components

Cycle Detection

Bipartite Check

Dijkstra's Algorithm

Bellman-Ford Algorithm

Floyd-Warshall Algorithm

Kruskal's MST Algorithm

Prim's MST Algorithm

Bridges and Articulation Points

Strongly Connected Components

19

Greedy

9 lessons

Greedy Algorithms — Foundations

Activity Selection and Interval Scheduling

Fractional Knapsack

Job Scheduling with Deadlines

Minimum Platforms and Meeting Rooms

Greedy on Arrays

Greedy on Graphs — MST and Dijkstra

Proving Greedy Algorithms Correct

20

Backtracking

8 lessons

Backtracking — Foundations

Combinations and Combination Sum

Word Search in a Grid

Backtracking — Summary and Pruning Strategies

21

Dynamic programming

20 lessons

Dynamic Programming Basics

Memoization vs Tabulation

Fibonacci-Style DP

Unbounded Knapsack

Longest Common Subsequence

Longest Increasing Subsequence

Coin Change Problems

Matrix Chain Multiplication

Palindromic Subsequences and Partitioning

Probability and Expected Value DP

Stock Buy and Sell Problems

DP Optimization Techniques

DP Problem Taxonomy and Summary

22

Trie

6 lessons

Trie Implementation

Prefix Search and Autocomplete

Word Break, Dictionary Matching, and Wildcards

Trie Summary and Advanced Concepts

23

Segment tree

7 lessons

Segment Tree Basics

Build and Query

Lazy Propagation

Segment Tree Beats

Fenwick Tree (Binary Indexed Tree)

Segment Tree Applications

24

Disjoint set

5 lessons

Union-Find Basics

Path Compression

Union-Find Applications

Advanced Union-Find

25

Agentic AI

32 lessons

How transformers work

Inference mechanics

The context window is your RAM

Tokenization and encoding

Prompting is programming

Tool use fundamentals

Designing good tool schemas

Parallel and sequential tool calls

Error recovery in tool loops

Planning agents

Multi-agent systems

Memory architecture

Human-in-the-loop design

Embeddings and vector search

Chunking strategies

RAG pipeline anatomy

Hybrid search and reranking

Structured output

Chain of thought and variants

Prompt injection and adversarial inputs

Context management in long sessions

When to fine-tune vs. prompt

LoRA and parameter-efficient fine-tuning

RLHF and preference tuning

Evaluation and preventing regression

Latency and cost tradeoffs

Observability for agents

Safety and guardrails

Agent state management

Deployment patterns