Data Structures on Chen Kai Blog

LeetCode (10): Patterns — Stack and Queue

Tue, 13 Sep 2022 09:00:00 +0000

Stacks and queues may seem unassuming next to graphs or dynamic programming, but they underpin a surprising number of interview problems. The reason is simple: most algorithmic questions are really about order of access. Stacks provide LIFO (last in, first out), while queues offer FIFO (first in, first out). Add variants like monotonic stacks, deques, and priority queues, and you can efficiently solve problems like bracket matching, next-greater-element, sliding-window extrema, top-K, BFS, and a long list of “implement X using Y” puzzles.

LeetCode (9): Patterns — Greedy Algorithms

Mon, 29 Aug 2022 09:00:00 +0000

The greedy algorithm paradigm seems too good to be true: at every step, choose the option that looks best right now, never look back, and somehow reach the global optimum. When it works, the code is almost embarrassingly short. When it doesn’t, it produces confidently wrong answers — which is why the real skill is recognizing when greedy is allowed.

This article walks through the structural reason greedy is correct on some problems and broken on others, then applies that lens to seven LeetCode classics: Jump Game, Jump Game II, Gas Station, Best Time to Buy and Sell Stock II, Non-overlapping Intervals, Task Scheduler, and Partition Labels.

LeetCode (8): Patterns — Backtracking Algorithms

Sun, 14 Aug 2022 09:00:00 +0000

Backtracking is the algorithm you use when a problem asks you to enumerate something — every permutation, every subset, every legal board, every path through a grid. It’s brute force with a brain: you build a candidate solution one decision at a time, abandon it as soon as a constraint says “this won’t work,” and undo your last move so the next branch starts fresh. The whole technique fits in three lines:

LeetCode (7): Patterns — Dynamic Programming Basics

Sat, 30 Jul 2022 09:00:00 +0000

Dynamic programming has a reputation for being the algorithm topic that separates “competent coder” from “interview wizard”. A lot of that reputation is unearned. DP is not a bag of clever tricks; it is a single recipe applied to problems that happen to have repeated subproblems. If you can answer three questions cleanly, you can solve almost any DP problem on LeetCode:

LeetCode (6): Patterns — Binary Tree Traversal and Construction

Fri, 15 Jul 2022 09:00:00 +0000

A binary tree problem is rarely about the tree itself. It’s about the order in which you visit nodes and what you remember from the children before deciding what to do at the parent. Once these two ideas click, the four traversal orders, iterative rewrites, construction problems, and even classics like Validate BST and Maximum Depth all boil down to variations of the same recipe. This article builds that recipe from start to finish.

LeetCode (5): Patterns — Binary Search

Thu, 30 Jun 2022 09:00:00 +0000

Binary search is the algorithm everyone thinks they understand until they have to write it under interview pressure. The idea is one sentence — halve the search space at every step — but the implementation is a minefield of off-by-one errors, infinite loops, and subtly wrong return values. The goal of this article is not to give you yet another recitation of the standard template. Instead, it aims to provide a mental model that explains why each template looks the way it does, along with a small toolkit (three templates plus the answer-space pattern) that covers the vast majority of LeetCode problems.

LeetCode (4): Patterns — Sliding Window Technique

Wed, 15 Jun 2022 09:00:00 +0000

If you have ever caught yourself writing a double for loop to inspect every contiguous subarray, sliding window is probably the optimisation you are missing. It turns an $$O(nk)$$ or $$O(n^2)$$ scan into a single linear pass by reusing the work it has already done. This article walks through the technique from first principles, then drills four canonical LeetCode problems plus a monotonic-deque variant.

LeetCode (3): Patterns — Linked List Operations

Tue, 31 May 2022 09:00:00 +0000

A linked list is the simplest data structure that forces you to think in pointers. Arrays let you index in $$O(1)$$ and forget about layout; linked lists hand you a head pointer and ask, “now what?” That single shift — from indices to references — is what makes linked-list problems so common in interviews. They are short to state, brutal to get right, and reward exactly the habits good engineers build: drawing pictures, naming pointers, and never dereferencing without checking for None.

LeetCode (2): Patterns — Two Pointers

Mon, 16 May 2022 09:00:00 +0000

Hash tables buy you speed by spending memory. Two pointers is the opposite trade: spend a little structural assumption — the array is sorted, the list might have a cycle, the answer lives in a contiguous window — and you get $$O(n)$$ time with $$O(1)$$ extra space. The pattern looks trivial in code (two indices and a while loop) but it has more failure modes than any other beginner technique: off-by-one indices, infinite loops, missed duplicates, wrong pointer moved on tie. The cure is to think in invariants rather than in moves.

LeetCode (1): Patterns — Hash Tables

Sun, 01 May 2022 09:00:00 +0000

A hash table is the cheapest superpower in your toolbox. You spend a constant amount of memory per stored item, and in return every “is x in here?” question costs roughly one CPU instruction. Whole families of O(n²) brute-force solutions collapse into a single O(n) pass once you reach for one.

This article is the first installment of the LeetCode Patterns series. We will build hash table intuition from scratch, then work through four template problems — Two Sum, Group Anagrams, Longest Substring Without Repeating Characters, and Top K Frequent Elements — each illustrating a reusable pattern you will see again and again on harder problems.