Algorithm

Data structures and algorithms overview.

Dynamic array implementation and two-pointer patterns.

Map implementations using a binary search tree and a hash table.

Singly linked list, doubly linked list, circular doubly linked list, and problem-solving patterns.

Queue, circular queue, priority queue, and deque.

An unordered set without duplicate elements.

A last-in-first-out stack.

Binary trees, BST, AVL tree, Trie, and Huffman tree.

Red-black tree properties, 2-3 trees, and implementation.

Skip-list basics, motivation, implementation, and expected complexity.

Heap properties, max heap implementation, and min heap notes.

BitMap basics, example, and why it saves space.

Why BloomFilter is needed, how it works, use cases, and a Go implementation.

Graph basics, representations, traversal, and implementations.

Union-Find, Quick Find, Quick Union, and optimizations.

LSM basics, SSTables, operations, and comparison with B-trees.

LeetCode notes on the Longest Common Substring problem.

ziplist and why it saves memory.

LeetCode notes on the Longest Common Subsequence problem.

B Tree, why it is used, and its relationship with B+ Tree.

LeetCode notes on the longest substring without repeating characters.

Sparse indexes and comparison with dense indexes.

What an index is, index types, implementations, and selection considerations.

Forward index and inverted index.

FIFO, LRU, LFU, and related cache replacement policies.

Dynamic programming steps and a path-counting example.

Greedy choices with loading, coin change, and 0-1 knapsack examples.

Divide a problem into smaller subproblems, solve them, and derive the original solution.

Recursion, its call process, basic ideas, examples, conversion to iteration, and tail recursion.

LeetCode notes on the Edit Distance problem.

Backtracking and the Eight Queens problem.

Depth-first search with permutation and combination examples.

Binary search, variants, and common templates.

Bubble sort, its characteristics, implementation, and optimization.

Linear search and its implementation.

Heap sort using heap construction and repeated deletion.

LeetCode notes on the Next Permutation problem.

Merge sort, its characteristics, process, and implementation.

LeetCode notes on the Permutations problem.

Insertion sort, its characteristics, process, and implementation.

LeetCode notes on the Subsets problem.

Quick sort, its characteristics, partitions, and implementations.

LeetCode notes on the Unique Paths problem.

Selection sort, its characteristics, process, and implementation.

LeetCode notes on the Number of Islands problem.

Common sorting algorithms and a complexity comparison.

The basic CAS semantics, use cases, ABA problem, and CPU atomic-instruction implementation.

LeetCode notes on the Maximal Square problem.

A historical CAS-based lock-free queue implementation note and its safe-memory-reclamation boundary.

Course Schedule problem using DFS and BFS topological sorting.

LeetCode notes on the Partition Equal Subset Sum problem.

Word Break using DFS and DFS with memoization.

LeetCode notes on the Perfect Squares problem.

Word search in a two-dimensional grid using DFS.

LeetCode notes on the Target Sum problem.

A note for the longest common substring problem.

LeetCode notes on the Combination Sum problem.

Design an LRU cache with a map and a doubly linked list, with Go and Java implementations.

LeetCode notes on the Coin Change problem.

Longest common subsequence using recursion, DFS with memoization, and dynamic programming.

LeetCode notes on the Burst Balloons problem.

Letter combinations of a phone number using DFS to enumerate combinations.

LeetCode notes on the House Robber problem.

Edit distance using recursion and recursion with memoization.

LeetCode notes on the Best Time to Buy and Sell Stock with Cooldown problem.

Group anagrams using a brute-force method and hashing.

LeetCode notes on the Minimum Path Sum problem.

Find all anagrams in a string using brute force and a sliding window with counts.

LeetCode notes on the Longest Increasing Subsequence problem.

Longest common prefix using a brute-force approach, with a trie idea noted.

LeetCode notes on the Jump Game problem.

LeetCode notes on the Maximum Product Subarray problem.

Check whether a string is a palindrome using reversal and two pointers.

LeetCode notes on the Maximum Subarray problem.

A Go implementation for reversing a string.

LeetCode notes on the First Missing Positive problem.

Count palindromic substrings using brute force and center expansion.

LeetCode notes on the 3Sum problem.

LeetCode notes on the Find the Duplicate Number problem.

Longest palindromic substring using brute force and center expansion.

LeetCode notes on the Two Sum problem.

LeetCode notes on finding all disappeared numbers in an array.

Add large numbers represented as strings by scanning from right to left and carrying.

LeetCode notes on the Subarray Sum Equals K problem.

LeetCode notes on the Longest Consecutive Sequence problem.

Decode strings in k[encoded_string] form using a stack.

Use a stack to mark matched parentheses, then count the longest consecutive valid interval.

Enumerate whether to keep or remove each character, then keep the longest valid-parentheses results.

Generate parentheses using full enumeration with a stack, and pruning based on remaining left/right parentheses.

Validate a parentheses sequence using a stack or repeated string replacement.

Regular expression matching with support for . and *.

LeetCode notes on binary-search upper bound.

Find the longest substring without repetition using a brute-force set approach and a sliding window.

LeetCode notes on finding the first and last position of an element in a sorted array.

Use weighted union-find to evaluate division relationships between variables.

Count the number of 1 bits in every integer from 0 through num.

Compute the Hamming distance between two integers using bitwise operations.

LeetCode notes on binary-search upper bound.

Reverse the decimal digits of a 32-bit signed integer and handle overflow.

LeetCode notes on finding the first and last position of an element in a sorted array.

Count the ways to climb stairs using a Fibonacci recurrence.

LeetCode notes on searching in a rotated sorted array.

LeetCode notes on searching in a rotated sorted array.

Merge two sorted integer arrays into one sorted array.

LeetCode notes on the Find Peak Element problem.

Find the K-th largest element in an array using sorting or quicksort partitioning.

Use binary search to find a target value in a sorted ascending integer array.

LeetCode notes on finding the minimum in a rotated sorted array.

LeetCode notes on computing an integer square root.

Traverse a matrix in clockwise spiral order.

Find the smallest letter greater than the target in a cyclically ordered character list.

LeetCode notes on the Trapping Rain Water problem.

LeetCode notes on the Container With Most Water problem.

Sort first and then insert by position to reconstruct a queue described by height and preceding-person counts.

Rearrange non-negative integers so their concatenation forms the largest integer.

Generate all string permutations using recursive backtracking, deduplicate them, and sort them lexicographically.

Find the top K frequent elements using frequency counting with sorting or a min-heap.

Find the majority element using a counting map or candidate cancellation.

Find the element that appears only once using counting or XOR.

Move all zeroes to the end of the array while preserving the relative order of non-zero elements.

Compute the product of array elements except self using left and right product arrays.

Sort 0, 1, and 2 in place using quicksort, bucket sort, or the move-zeroes idea.

Search a matrix whose rows and columns are both sorted, starting from the top-right corner.

Use the Fibonacci recurrence to calculate the number of ways a frog can climb the stairs.

Derive the number of ways to climb stairs when each jump may cover any number of steps using a recurrence and a pattern.

Record three implementations of the Fibonacci sequence: recursion, memoization, and dynamic programming.

Count the number of 1 bits in a 32-bit binary representation by shifting through each bit.

Calculate a floating-point number raised to an integer power using repeated multiplication, including negative exponents.

Enumerate integers and use modulo operations to count occurrences of digit 1 in decimal representations from 1 to n.

LeetCode notes on the Maximum Product Subarray problem.

Use a map to count character occurrences while preserving input order to find the first character that appears only once in a stream.

LeetCode notes on the brute-force solution for Subarray Sum Equals K.

Record two implementations of cyclic left rotation of a string: slicing and concatenation, and three reversals.

LeetCode notes on the brute-force solution for Maximal Square.

Sort five cards, treat jokers as 0, and use the gaps between non-zero cards to determine whether they can form a straight.

LeetCode notes on the brute-force solution for Daily Temperatures.

Record two implementations for replacing spaces with %20: character-by-character concatenation and preallocated storage.

LeetCode notes on Daily Temperatures with brute force and a monotonic stack.

Record recursive and stack-based methods for outputting a linked list from tail to head.

LeetCode notes on Sliding Window Maximum using brute force, a priority queue, and a monotonic deque.

Record stack-based and three-pointer implementations for reversing a singly linked list.

LeetCode notes on merging overlapping intervals.

LeetCode notes on implementing a stack that retrieves the minimum element in constant time.

Record iterative and recursive implementations for merging two sorted linked lists.

LeetCode notes on sorting an array with merge sort and quicksort.

Record array, length-conversion, and fast-slow-pointer methods for finding the k-th node from the end.

LeetCode notes on finding the median of two sorted arrays by merging them.

LeetCode notes on the Jump Game problem.

Record the method of copying a complex linked list by inserting copied nodes after the original nodes.

LeetCode notes on finding the shortest continuous subarray that must be sorted.

Record set-based and fast/slow-pointer methods for finding the entry node of a linked-list cycle.

LeetCode notes on maximizing profit from one stock transaction.

Record a two-pointer method that uses the length difference to find the first common node of two linked lists.

LeetCode notes on rotating an n x n matrix 90 degrees clockwise.

Record counting- and set-based methods for deleting all duplicate nodes from a sorted linked list.

LeetCode notes on implementing a Trie prefix tree.

Record a recursive method for determining whether a sequence is the postorder traversal result of a binary search tree.

LeetCode notes on counting unique binary search trees with DFS, memoization, and dynamic programming.

Record methods for finding the inorder successor of a binary-tree node through a full inorder traversal or parent-pointer relationships.

LeetCode notes on binary tree inorder traversal with recursion and color marking.

Record inorder-traversal and recursive methods for converting a binary search tree into a sorted doubly linked list.

LeetCode notes on reconstructing a binary tree from preorder and inorder traversals.

Record inorder-traversal methods for finding the kth smallest node in a binary search tree, plus reverse inorder traversal for the kth largest node.

Notes on implementing preorder, inorder, and postorder traversal of a binary tree.

Record a recursive method for computing binary-tree depth by taking the greater depth of the left and right subtrees.

LeetCode notes on converting a binary search tree to a Greater Sum Tree.

Record queue-based level-order traversal for printing binary-tree nodes from top to bottom.

LeetCode notes on validating a binary search tree with inorder traversal.

Record a recursive method for determining whether a binary tree is symmetric by comparing mirrored positions in its left and right subtrees.

LeetCode notes on flattening a binary tree into a linked list in preorder.

Record a method for determining whether a binary tree is balanced by comparing subtree heights and recursively checking both subtrees.

LeetCode notes on finding the lowest common ancestor in a binary tree.

Record recursive, stack-based, and queue-based methods for generating the mirror of a binary tree by swapping left and right subtrees.

LeetCode notes on calculating the diameter of a binary tree.

Record a queue-based method that uses end-of-line pointers to print a binary tree level by level, one line per level.

Notes on finding the lowest common ancestor of two nodes in a binary tree.

Record a zigzag traversal method by reversing alternating rows after level-order traversal.

LeetCode notes on merging two binary trees.

Record a preorder-recursive matching method for determining whether one binary tree is a substructure of another.

LeetCode notes on checking whether a binary tree is mirror-symmetric.

Record the recursive method for reconstructing a binary tree from preorder and inorder traversal results.

LeetCode notes on House Robber III using DFS and memoization.

Record the depth-first, preorder traversal, and backtracking method for finding binary-tree paths with a given sum.

LeetCode notes on summing all numbers formed by root-to-leaf paths.

Record methods for serializing and deserializing a binary tree using preorder traversal and a preorder-plus-inorder traversal combination.

LeetCode notes on Invert Binary Tree.

Record character parsing and atoi implementations for converting a string to an integer.

LeetCode notes on Path Sum III.

Record methods for reversing word order by splitting the string and by reversing twice.

LeetCode notes on Maximum Depth of Binary Tree.

Record using an auxiliary minimum stack to retrieve the stack minimum in O(1) time.

LeetCode notes on Binary Tree Maximum Path Sum.

Record methods that use an auxiliary stack to determine whether a given sequence is a valid pop sequence.

LeetCode notes on Binary Tree Right Side View.

Record how to implement queue Push, Pop, Peek, and Empty operations using two stacks.

LeetCode notes on Binary Tree Level Order Traversal.

Mirror translation of the original Sword Offer note: Search in a 2D Array.

LeetCode notes on Serialize and Deserialize Binary Tree.

Mirror translation of the original Sword Offer note: Two Numbers with Sum S.

LeetCode notes on Binary Tree Zigzag Level Order Traversal.

Mirror translation of the original Sword Offer note: Continuous Positive Sequences with Sum S.

LeetCode notes on Swap Nodes in Pairs.

Mirror translation of the original Sword Offer note: Last Remaining Number in a Circle.

LeetCode notes on Reverse Linked List II.

Mirror translation of the original Sword Offer note: Arrange an Array into the Smallest Number.

LeetCode notes on Reverse Linked List.

Mirror translation of the original Sword Offer note: Count Occurrences in a Sorted Array.

LeetCode notes on Reverse Nodes in k-Group.

Mirror translation of the original Sword Offer note: Number Appearing More Than Half the Time.

LeetCode notes on Add Two Numbers.

Mirror translation of the original Sword Offer note: Numbers Appearing Only Once.

LeetCode notes on Remove Duplicates from Sorted List II.

Mirror translation of the original Sword Offer note: Inverse Pairs in an Array.

LeetCode notes on Remove Duplicates from Sorted List.

Mirror translation of the original Sword Offer note: Duplicate Number in an Array.

LeetCode notes on Remove Nth Node From End of List.

Mirror translation of the original Sword Offer note: Minimum Number in a Rotated Array.

LeetCode notes on Palindrome Linked List.

Mirror translation of the original Sword Offer note: Smallest K Numbers.

LeetCode notes on Palindrome Linked List.

Mirror translation of the original Sword Offer note: Robot Movement Range.

LeetCode notes on Linked List Cycle.

Mirror translation of the original Sword Offer note: Maximum in Sliding Windows.

LeetCode notes on Linked List Cycle II.

Mirror translation of the original Sword Offer note: Reorder Array with Odd Numbers Before Even Numbers.

LeetCode notes on Rotate List.

Mirror translation of the original Sword Offer note: Maximum Sum of a Contiguous Subarray.

LeetCode notes on Linked List Cycle.

LeetCode notes on Linked List Cycle II.

LeetCode notes on Intersection of Two Linked Lists.

LeetCode notes on Reorder List.

LeetCode notes on Partition List.

LeetCode notes on Merge k Sorted Lists.

LeetCode notes on Merge Two Sorted Lists.

LeetCode notes on Odd Even Linked List.

LeetCode notes on Sort List.

LeetCode notes on Intersection of Two Linked Lists.