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.

Apply the binary search template to related problems, find the first or last position of a target in arrays with duplicates, and master left and right pointer logic.

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.

We cover binary search and exponential backoff, solve fast power in recursive and non recursive forms, and discuss greatest common divisor, negative integers, and log time strategies.

Explore two-pointer techniques, pivot-based partition in quicksort, and the merge process in mergesort, then compare their time and space complexity and learn practical sorting templates.

Develop a two-pointer solution to move all zeros to the end of the array, preserving the relative order of non-zero elements with no extra space and minimizing operations.

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.

Apply the two-pointer technique from the start and end toward each other to determine a palindrome, including the at-most-one-deletion variant and its time complexity.

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 binary tree BFS questions: bottom-up level order traversal, zigzag level order, and vertical order traversal, using level-order concepts, optional reversal, and a second queue for column indices.

Count islands in a binary matrix using BFS from unvisited land cells, exploring 4-direction neighbors with a visited map; discuss code structure and bidirectional BFS as optimization.

Sorts topological orders on directed graphs by building the graph and in-degree map, then breadth-first search with zero in-degree nodes; applies to course schedules and alien dictionaries.

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.

Learn to find the minimum subtree sum in a binary tree, compare brute-force with optimized subtree-sum calculations, and apply a bottom-up divide-and-conquer approach.

Learn how to generate root-to-leaf paths in a binary tree using divide-and-conquer, and find the lowest common ancestor for two nodes with case analysis.

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 binary search trees, their left-subtree less-than root and right-subtree greater-than root properties, and how in-order traversal yields a non decreasing sequence; discuss height, depth, and balance basics.

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 permutation based DFS to solve permutation problems, differentiate permutation from combination, apply the multiplication principle and factorial time complexity, and learn handling duplicates, next and previous permutations.

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 what data structures are and how they enable efficient access and modification, covering hash tables, hash maps, open and closed hashing, rehashing, and evaluating time complexity for interview questions.

Explore queue and stack data structures, detailing push, pop, and top operations with O(1) time, and apply queues to sliding window moving averages for online data streams.

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.

Explore solving the kth largest element ii using a heap-based data structure and quick select. Learn offline and online variants, implement top-k operations, and analyze time complexity.

Explore data structure concepts, including merging intervals, inserting into sorted intervals, quicksort, mergesort, prefix techniques, matrix questions, and a new data structure.

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.

Boost coding interview readiness with data structures, dynamic programming, and monthly interview question updates, plus upcoming courses on advanced topics and an assistant design course for seniors.