Coding Interview Bootcamp: Algorithms (Java, Python, C++)

Explore binary search templates for finding the first and last indices and for half searches. Understand time and space complexity, recursion vs non recursion, and stack considerations.

Learn a binary search template that prevents infinite loops and overflow, handles duplicates, and uses left and right pointers with mid calculation and a proper end condition.

Demonstrates binary search templates to find the first bad version and its border, then uses two-pointer methods to identify the k numbers closest to a target by absolute difference.

Learn to locate a peak in an array using binary search and to search a target in a rotated sorted array by comparing halves and choosing the proper side.

Master minimum window substring with a sliding window, two pointers, and a hash map to track required characters, expanding the right pointer and shrinking the left to cover all targets.

Explore two sum and related questions using hash maps and two-pointer techniques, covering duplicates handling, three-sum problems, triangle counting, and optimized time complexities.

Explore the two pointers partition approach, including left and right pointers, quicksort and quickselect templates, and three-way partition strategies for problems like rainbow sort and sorting colors.

Explore binary tree serialization and deserialization, focusing on preorder traversal and a queue-based reconstruction to ensure readable formats like xml and json.

Explore graph algorithms for coding interviews by comparing bfx over dfs, exploring shortest paths, topological sort, and bidirectional bfx, while writing clean, maintainable code with inbound validity checks.

Explore binary tree based dfs, including in-order, pre-order, and post-order traversals, and compare iterative and recursive implementations within a divide and conquer and backtracking framework.

Flatten a binary tree to a linked list in preorder using an in-place divide-and-conquer approach, tracking the last node to attach left and right subtrees without extra space.

Explore recursive and iterative solutions for in-order, pre-order, and post-order traversals on binary trees, using a stack and depth-first search.

Explore how to implement a BST iterator with next using an iterative in-order traversal, and learn the BST successor concept and its iterative solution.

Learn to find the closest value to a target in a binary search tree by using lower and upper bounds, path-based search with stacks, and an array-free O(h) solution.

Explore combination-based dfs techniques, subset generation, and when to use dfs vs bfs, detailing recursive function factors, deep copy basics, and time complexity in practice.

Learn backtracking with a dfs template to generate all combinations summing to a target, for unlimited-use and once-only candidates, with duplicate handling.

Explore how to generate all letter combinations from digits 2–9 using backtracking, and prune with a prefix map or trie to improve DFS efficiency.

Dive into word pattern ii, solving by backtracking that maps pattern characters to substrings with a bijection to string s, using a map and a visited set to prune paths.

Explore word ladder ii as an implicit graph problem, using bfs to find the shortest transformation sequences and dfs to enumerate all optimal paths through pruning with a distance map.

Learn to solve word search ii on a character grid where words connect horizontally or vertically, using dfs with visited constraints and a prefix trie to prune by prefixes.

Explore hash maps and LRU cache concepts, including get and put operations, least recently used eviction, and how a doubly linked list with a hash map enables one-time complexity.

Explore building a data structure with insert, delete, and getRandom in O(1) average using a hash map and array, swapping with the last item for efficient removal and uniform randomness.

Explore how to identify the first unique character in a data stream using a hash map and a linked list, with dummy nodes and online updates.

Learn to merge sorted arrays with and without extra space, and extend to merging overlapping intervals using a comparator and pointers, including k-way merging with a heap.

Explore techniques to compute the intersection of two arrays, including hash map, sorting with binary search, and two-pointer merging, with and without duplicates.

Explore prefix sum techniques on matrices to count submatrices summing to a target and to maximize submatrix sums not exceeding k, using hashing and efficient preprocessing.

Explore efficient median finding for two sorted arrays using binary search, and extend to k sorted arrays with a binary search on the result to improve time complexity.

Apply union-find to manage disjoint sets, using find with path compression to locate representatives and union by size to merge sets and track connected components.