Beyond 'It Works'
Measuring Performance
The Big O Story
Constant Time: O(1)
Linear Time: O(N)
Quadratic Time: O(N²)
Logarithmic Time: O(log N)
Space Complexity: O(1), O(N)
Lists: Dynamic Arrays
Tuples: Immutable Sequences
Dictionaries: Hash Maps
Sets: Unique Collections
Choosing the Right Tool
Arrays: The Basics
Python Lists as Arrays
Dynamic Array Mechanics
Building a Dynamic Array
Array Ops: Time & Space
Linked List: The Idea
Singly Linked List Node
Singly Linked List: Init
SLL: Insertion
SLL: Traversal & Search
SLL: Deletion
SLL Ops: Time & Space
Doubly Linked List Node
DLL: Insertion & Deletion
DLL Ops: Time & Space
What's a Stack?
Stack with Python Lists
Stack with Linked Lists
Balancing Parentheses
Expression Evaluation
Function Call Stack
What's a Queue?
Queue with Python Lists
Queue with Collections.deque
Queue with Linked Lists
Task Scheduling
BFS Intro
Request Handling
What's a Hash Table?
The Magic of Hashing
Python's Dicts: Under the Hood
Our First Hash Table
Adding & Getting Data
When Hashes Collide
Chaining: Linked Solutions
Open Addressing: Linear
Open Addressing: Quadratic
Open Addressing: Double
Load Factor & Resizing
Hash Table Performance
Hash Tables in Backend
Hash Tables in Data Eng.
Why Trees?
Tree Terminology
Tree vs. Graph
What's a Binary Tree?
Representing Binary Trees
Inserting Nodes
In-Order Traversal
Pre-Order Traversal
Post-Order Traversal
Traversal Use Cases
Finding Tree Height
Counting Nodes
Tree Operation Costs
What's a BST?
Building Blocks: BST Node
The BST Class
Adding Elements to BST
Finding Elements in BST
Min and Max in BST
Removing Elements from BST
BST Time Complexity
BST Space Complexity
Why Balance Matters
Balanced BSTs: An Intro
BSTs for Ordered Data
BSTs in Action
Why Sort Data?
Sorting Basics & Stability
Bubble Sort: The Basics
Selection Sort: Picking Min
Insertion Sort: Card Game
Merge Sort: Divide & Conquer
Quick Sort: Pivot & Partition
Quick Sort Optimizations
Heap Sort: The Heap Way
Counting Sort: For Integers
Radix Sort: Digit by Digit
Comparing Sorts: Big O
Stability & In-Place Sorts
Python's Timsort
Choosing the Right Sort
What's a Search?
Linear Search: The Basics
Linear Search: Complexity
Divide & Conquer: Intro
Divide & Conquer in Action
Binary Search: The Idea
Binary Search: Iterative
Binary Search: Recursive
Binary Search: Complexity
Search: When to Use What
Binary Search in Data Eng
Binary Search in Backend
What's a Graph?
Graph Terminology
Adjacency Matrix
Adjacency List
Matrix vs. List
BFS: The Level-by-Level Tour
Implementing BFS
BFS Complexity & Uses
DFS: The Deep Dive
Implementing DFS (Recursive)
Implementing DFS (Iterative)
DFS Complexity & Uses
BFS for Shortest Path
DFS for Cycle Detection
Topological Sort with DFS
BFS Complexity Analysis
DFS Complexity Analysis
Graph Rep. Impact
Network Routing Basics
Dependency Resolution
Data Lineage & ETL
Social Networks & Recs
Backend API Routing
When to Use Graphs
Graph Modeling Practice
Recursion: The Basics
Recursive Problem Solving
Recursion vs. Iteration
Tail Recursion & Optimization
Greedy Approach Explained
Greedy in Action
When Greedy Works (or Not)
Choosing the Right Tool
Performance Trade-offs
Problem Decomposition
Optimizing for Scale
Real-World Problem Walk