DSA

Introduction to DSA

Why data structures and algorithms matter, and Big-O basics.

Arrays & Time Complexity

How arrays work, the cost of common array operations, and analyzing an algorithm's time and space.

Simple Sorting: Bubble, Selection & Insertion

Three O(n²) sorting algorithms — how each works, step by step, and when they're useful.

Faster Sorting: Quick, Merge, Counting & Radix

Divide-and-conquer sorts that run in O(n log n), and non-comparison sorts that can beat it.

Searching: Linear & Binary Search

Linear search on any list, binary search on sorted data, and why O(log n) is so fast.

Linked Lists

Nodes and pointers, how linked lists sit in memory, singly/doubly/circular lists, and their operations.

Stacks & Queues

LIFO stacks and FIFO queues, their operations, implementations, and real-world uses.

Hash Tables, Hash Sets & Hash Maps

Hash functions, buckets and collisions, load factor, and O(1) lookups with sets and dictionaries.

Trees & Traversal

Tree terminology, binary trees, pre-order, in-order, and post-order traversal, and trees stored in arrays.

Binary Search Trees & AVL Trees

The BST property, search/insert/delete in O(h), why trees get unbalanced, and self-balancing AVL trees.

Graphs & Graph Traversal

Vertices and edges, directed and weighted graphs, adjacency lists and matrices, DFS, BFS, and cycle detection.

Shortest Paths & Minimum Spanning Trees

Dijkstra's and Bellman-Ford shortest-path algorithms, and Prim's and Kruskal's minimum spanning trees.

Maximum Flow

Flow networks, capacities, the Ford-Fulkerson method, residual graphs, and Edmonds-Karp.

Dynamic Programming

Overlapping subproblems and optimal substructure, memoization, tabulation, and the 0/1 knapsack problem.

Greedy & Classic Algorithms

Greedy algorithms and when they work, the Euclidean algorithm, Huffman coding, and the traveling salesman problem.