The toolkit every engineer is expected to know and every interview tests — taught by doing in Python. Reason about cost with Big-O, then build and use each structure (arrays and hashing, linked lists, stacks and queues, trees and heaps, graphs) and master the algorithms and problem-solving patterns (sorting, searching, recursion, backtracking, dynamic programming) that turn brute force into efficient solutions.
Before you start
You need one programming language you can read and write comfortably — every example here is in Python, so the Python course is the ideal prerequisite. The concepts transfer to any language.
Complexity & Big-O
Before any data structure, learn to measure cost. Big-O describes how an algorithm scales with input size, independent of hardware — the language you use to compare solutions and the reason the rest of DSA matters.
Arrays & Hashing
The two most-used structures: the array, contiguous memory with O(1) indexing, and the hash table, O(1) average lookup. Learn their costs and the single most powerful trick in DSA — trading space for time with a hash map.
Linked Lists, Stacks & Queues
Structures defined by how you add and remove. Linked lists trade index access for O(1) splicing; stacks are last-in-first-out; queues are first-in-first-out. Plus the fast & slow pointer pattern.
Sorting Algorithms
Sorting is the classic lens on algorithm design. Build the O(n²) sorts to see why they are slow, then merge sort and quicksort to see how divide-and-conquer reaches O(n log n) — and when to just call sorted().
Searching, Two Pointers & Sliding Window
Binary search turns O(n) lookups into O(log n) on sorted data. The two-pointer and sliding-window patterns bring many array and string problems down from O(n²) to O(n). Three techniques you will reuse constantly.
Recursion, Backtracking & Divide and Conquer
Recursion solves a problem in terms of smaller versions of itself. Divide and conquer splits, solves, and combines; backtracking explores choices and undoes them. The mental tools behind trees, graphs, and DP.
Trees & Heaps
Trees model hierarchy and enable O(log n) operations when balanced. Learn binary trees and traversals, binary search trees, self-balancing trees at a high level, and the heap — the structure behind priority queues.
Graphs
Graphs model anything with connections — networks, maps, dependencies. Learn to represent them, traverse with BFS and DFS, find shortest paths with Dijkstra and Bellman-Ford, and connect components with Union-Find.
Dynamic Programming & Problem-Solving Patterns
Dynamic programming solves problems with overlapping subproblems by remembering answers. Learn memoization and tabulation, greedy algorithms, and the recurring interview patterns that map a new problem to a known technique.