Glossary
Auto-generated index of key terms and which lesson covers them.
| Term | Lesson |
|---|---|
| 2D Grid DP | 16. Dynamic Programming |
| Amortized Complexity | 01. How to Think About Complexity |
| Backtracking vs DP | 13. Backtracking |
| Balanced vs Unbalanced | 10. Trees and BSTs |
| Bellman-Ford Algorithm | 15. Shortest Path and MST |
| Best, Worst, Average | 01. How to Think About Complexity |
| Beyond Quadratic | 01. How to Think About Complexity |
| BFS — Breadth-First Search | 14. Graphs |
| Binary Search Trees | 10. Trees and BSTs |
| Binary Tree Types | 10. Trees and BSTs |
| Bit Manipulation | 17. Greedy and Bit Manipulation |
| Bitmask as Set | 17. Greedy and Bit Manipulation |
| BST Deletion | 10. Trees and BSTs |
| BST Validation | 10. Trees and BSTs |
| Building a Heap is O(n) | 11. Heaps and Priority Queues |
| Classic Example: Climbing Stairs | 16. Dynamic Programming |
| Classic Example: Coin Change | 16. Dynamic Programming |
| Combinations (Choose K from N) | 13. Backtracking |
| Common Bit Tricks | 17. Greedy and Bit Manipulation |
| Common Bugs | 09. Binary Search |
| Common DP Categories | 16. Dynamic Programming |
| Common Graph Problems | 14. Graphs |
| Common Slice Operations | 02. Arrays Strings and Slices |
| Complexity | 14. Graphs |
| Contiguous Memory | 02. Arrays Strings and Slices |
| Core Operations | 12. Tries |
| Delete Operation | 12. Tries |
| Deque — Double-Ended Queue | 05. Stacks and Queues |
| DFS — Depth-First Search | 14. Graphs |
| DFS Patterns on Trees | 10. Trees and BSTs |
| Dijkstra's Algorithm | 15. Shortest Path and MST |
| DP vs Greedy | 16. Dynamic Programming |
| Essential Operations | 17. Greedy and Bit Manipulation |
| Frequency Counting | 02. Arrays Strings and Slices |
| Go Slices | 02. Arrays Strings and Slices |
| Go's map | 04. Hash Maps and Sets |
| Go's sort.Slice | 08. Sorting Algorithms |
| Greedy vs DP — How to Decide | 17. Greedy and Bit Manipulation |
| How Hash Maps Work | 04. Hash Maps and Sets |
| How to Analyze Code | 01. How to Think About Complexity |
| How to Recognize DP | 16. Dynamic Programming |
| Iterative DFS | 10. Trees and BSTs |
| Kadane's Algorithm | 03. Two Pointers and Sliding Window |
| Knapsack: 0/1 vs Unbounded | 16. Dynamic Programming |
| Kruskal's Algorithm | 15. Shortest Path and MST |
| Kruskal's vs Prim's | 15. Shortest Path and MST |
| LeetCode 1 - Two Sum | 04. Hash Maps and Sets |
| LeetCode 1143 - Longest Common Subsequence | 16. Dynamic Programming |
| LeetCode 136 - Single Number | 17. Greedy and Bit Manipulation |
| LeetCode 141 - Linked List Cycle | 03. Two Pointers and Sliding Window |
| LeetCode 152 - Maximum Product Subarray | 03. Two Pointers and Sliding Window |
| LeetCode 20 - Valid Parentheses | 05. Stacks and Queues |
| LeetCode 200 - Number of Islands | 14. Graphs |
| LeetCode 206 - Reverse Linked List | 06. Linked Lists |
| LeetCode 208 - Implement Trie (Prefix Tree) | 12. Tries |
| LeetCode 209 - Minimum Size Subarray Sum | 03. Two Pointers and Sliding Window |
| LeetCode 210 - Course Schedule II | 14. Graphs |
| LeetCode 23 - Merge K Sorted Lists | 11. Heaps and Priority Queues |
| LeetCode 239 - Sliding Window Maximum | 05. Stacks and Queues |
| LeetCode 242 - Valid Anagram | 02. Arrays Strings and Slices |
| LeetCode 26 - Remove Duplicates from Sorted Array | 02. Arrays Strings and Slices, 03. Two Pointers and Sliding Window |
| LeetCode 295 - Find Median from Data Stream | 11. Heaps and Priority Queues |
| LeetCode 3 - Longest Substring Without Repeating Characters | 03. Two Pointers and Sliding Window |
| LeetCode 322 - Coin Change | 16. Dynamic Programming |
| LeetCode 33 - Search in Rotated Sorted Array | 09. Binary Search |
| LeetCode 347 - Top K Frequent Elements | 11. Heaps and Priority Queues |
| LeetCode 39 - Combination Sum | 13. Backtracking |
| LeetCode 416 - Partition Equal Subset Sum | 16. Dynamic Programming |
| LeetCode 435 - Non-overlapping Intervals | 17. Greedy and Bit Manipulation |
| LeetCode 450 - Delete Node in a BST | 10. Trees and BSTs |
| LeetCode 46 - Permutations | 13. Backtracking |
| LeetCode 496 - Next Greater Element I | 05. Stacks and Queues |
| LeetCode 51 - N-Queens | 13. Backtracking |
| LeetCode 53 - Maximum Subarray | 03. Two Pointers and Sliding Window |
| LeetCode 547 - Number of Provinces | 15. Shortest Path and MST |
| LeetCode 55 - Jump Game | 17. Greedy and Bit Manipulation |
| LeetCode 56 - Merge Intervals | 17. Greedy and Bit Manipulation |
| LeetCode 62 - Unique Paths | 16. Dynamic Programming |
| LeetCode 70 - Climbing Stairs | 16. Dynamic Programming |
| LeetCode 704 - Binary Search | 09. Binary Search |
| LeetCode 72 - Edit Distance | 16. Dynamic Programming |
| LeetCode 743 Variant - Network Delay Time | 15. Shortest Path and MST |
| LeetCode 77 - Combinations | 13. Backtracking |
| LeetCode 78 - Subsets | 13. Backtracking |
| LeetCode 787 - Cheapest Flights Within K Stops | 15. Shortest Path and MST |
| LeetCode 88 - Merge Sorted Array | 02. Arrays Strings and Slices |
| LeetCode 98 - Validate Binary Search Tree | 10. Trees and BSTs |
| LeetCode 994 - Rotting Oranges | 14. Graphs |
| Left and Right Boundaries | 09. Binary Search |
| Lowest Common Ancestor (LCA) | 10. Trees and BSTs |
| make() — Length vs Capacity | 02. Arrays Strings and Slices |
| Memoization (Top-Down) vs Tabulation (Bottom-Up) | 16. Dynamic Programming |
| Memoization vs Tabulation | 16. Dynamic Programming |
| Memoization with Map | 16. Dynamic Programming |
| Merge Sort | 08. Sorting Algorithms |
| Minimum Spanning Tree | 15. Shortest Path and MST |
| Monotonic Stack | 05. Stacks and Queues |
| Multi-Source BFS | 14. Graphs |
| Multiple Recursive Calls | 07. Recursion |
| N-Queens (Classic Backtracking) | 13. Backtracking |
| Operations | 11. Heaps and Priority Queues |
| Partition: The Key Insight | 08. Sorting Algorithms |
| Pattern: Autocomplete | 12. Tries |
| Pattern: Deduplication | 04. Hash Maps and Sets |
| Pattern: Dummy Head | 06. Linked Lists |
| Pattern: Fast and Slow Pointers | 06. Linked Lists |
| Pattern: Frequency Counting | 04. Hash Maps and Sets |
| Pattern: Grouping | 04. Hash Maps and Sets |
| Pattern: Interval Scheduling | 17. Greedy and Bit Manipulation |
| Pattern: Jump Game | 17. Greedy and Bit Manipulation |
| Pattern: Merge Intervals | 17. Greedy and Bit Manipulation |
| Pattern: Merge K Sorted Lists | 11. Heaps and Priority Queues |
| Pattern: Reverse a Linked List | 06. Linked Lists |
| Pattern: Running Median (Two Heaps) | 11. Heaps and Priority Queues |
| Pattern: Top-K Elements | 11. Heaps and Priority Queues |
| Pattern: Two Sum (Index Lookup) | 04. Hash Maps and Sets |
| Pattern: Word Validation | 12. Tries |
| Permutations (All Orderings) | 13. Backtracking |
| Prim's Algorithm | 15. Shortest Path and MST |
| Priority Queue | 11. Heaps and Priority Queues |
| Pruning | 13. Backtracking |
| Queues — First In, First Out | 05. Stacks and Queues |
| Quicksort | 08. Sorting Algorithms |
| Recursion on Linked Lists | 07. Recursion |
| Recursion on Trees | 07. Recursion |
| Recursion vs Iteration | 07. Recursion |
| Representation | 14. Graphs |
| Ring Buffer (Circular Queue) | 05. Stacks and Queues |
| Rotated Sorted Array | 09. Binary Search |
| Rune vs Byte | 02. Arrays Strings and Slices |
| Search on Answer (Binary Search on Result) | 09. Binary Search |
| Sets | 04. Hash Maps and Sets |
| Shared Backing Arrays | 02. Arrays Strings and Slices |
| Sift Up and Sift Down | 11. Heaps and Priority Queues |
| Simple Sorts (O(n²)) | 08. Sorting Algorithms |
| Singly vs Doubly Linked | 06. Linked Lists |
| Sliding Window: Fixed Size | 03. Two Pointers and Sliding Window |
| Sliding Window: Variable Size | 03. Two Pointers and Sliding Window |
| Sorting as a Preprocessing Step | 08. Sorting Algorithms |
| Space Optimization | 16. Dynamic Programming |
| Stacks — Last In, First Out | 05. Stacks and Queues |
| String DP: LCS and Edit Distance | 16. Dynamic Programming |
| Strings in Go | 02. Arrays Strings and Slices |
| Subsets (All Combinations) | 13. Backtracking |
| The Basic Template | 09. Binary Search |
| The Call Stack | 07. Recursion |
| The DP Framework | 16. Dynamic Programming |
| The Five Common Classes | 01. How to Think About Complexity |
| The Practical Rule | 01. How to Think About Complexity |
| The Recursive Leap of Faith | 07. Recursion |
| The Slice Queue Memory Leak | 05. Stacks and Queues |
| The Two Parts | 07. Recursion |
| Time Complexity | 13. Backtracking |
| Time vs Space | 01. How to Think About Complexity |
| Topological Sort | 14. Graphs |
| Traversals | 10. Trees and BSTs |
| Trie vs Hash Map vs BST | 12. Tries |
| Two Pointers: Fast and Slow (Floyd's) | 03. Two Pointers and Sliding Window |
| Two Pointers: Opposite Direction | 03. Two Pointers and Sliding Window |
| Two Pointers: Same Direction | 03. Two Pointers and Sliding Window |
| Union-Find | 15. Shortest Path and MST |
| When Binary Search Applies | 09. Binary Search |
| When DFS vs BFS | 14. Graphs |
| When Greedy Works | 17. Greedy and Bit Manipulation |
| When NOT to Use Arrays | 02. Arrays Strings and Slices |
| When NOT to Use Hash Maps | 04. Hash Maps and Sets |
| When NOT to Use Heaps | 11. Heaps and Priority Queues |
| When NOT to Use Linked Lists | 06. Linked Lists |
| When NOT to Use Trees | 10. Trees and BSTs |
| When NOT to Use Tries | 12. Tries |
| When to Use Arrays | 02. Arrays Strings and Slices |
| When to Use Bit Manipulation | 17. Greedy and Bit Manipulation |
| When to Use Dijkstra vs BFS vs Bellman-Ford | 15. Shortest Path and MST |
| When to Use Hash Maps | 04. Hash Maps and Sets |
| When to Use Heaps | 11. Heaps and Priority Queues |
| When to Use Linked Lists | 06. Linked Lists |
| When to Use Stack vs Queue | 05. Stacks and Queues |
| When to Use Trees | 10. Trees and BSTs |
| When to Use Tries | 12. Tries |
| When to Use Two Pointers vs Sliding Window | 03. Two Pointers and Sliding Window |
| Where Queues Appear | 05. Stacks and Queues |
| Where Stacks Appear | 05. Stacks and Queues |
| Wildcard Matching | 12. Tries |
| XOR Properties | 17. Greedy and Bit Manipulation |