labuladong Algo Notes

This repository contains 60+ original articles based on LeetCode problems, covering all problem types and techniques. The goal is to help you think algorithmically — not just memorize solutions.

When it comes to LeetCode, what matters is not the answer itself, but the thought process behind it. A repository full of raw code without explanation isn’t very useful. The real value lies in understanding the frameworks and patterns that let you solve new problems on your own.

Most people grind LeetCode to land a job, not to compete in programming contests. So the focus here is on clarity and practical understanding — building reusable mental frameworks that make algorithm problems approachable and solvable.

Before You Start

1. Give this repo a star if you find it helpful — it keeps me motivated to write more.

2. I recommend studying on my website, where each article links to the corresponding LeetCode problems so you can read and practice side by side. The site covers 500+ problems with step-by-step guidance:

https://labuladong.online/en/algo/

Table of Contents

• Introduction

• Study Plans for Beginners and Quick Mastery

  • Fast-Track Learning Plan
  • Complete Learning Plan
  • How to Learn Algorithms Efficiently
  • How to Practice

• Tools and Algorithm Visualization

  • AI Assistant for Questions
  • Algorithm Visualization Introduction
  • Algorithm Game Introduction
  • Chrome Extension for LeetCode
  • vscode/cursor Plugin for LeetCode
  • JetBrains Plugin for LeetCode
  • Subscribe to Pro

• Programming Language Basics

  • Chapter Introduction
  • C++ Basics
  • Java Basics
  • Golang Basics
  • Python Basics
  • JavaScript Basics
  • LeetCode Guide
  • Let’s Have Fun with LeetCode
  • ACM Mode Code Template

• Getting Started: Data Structures and Sorting

  • Chapter Introduction

  • Basic Time Complexity

  • Implement Dynamic Arrays

    • Array (Sequential Storage)
    • Dynamic Array Code Implementation

  • Implement Single/Double Linked List

    • Linked List (Chain Storage)
    • Linked List Code Implementation
    • Implement Snake Game

  • Array and LinkedList Variations

    • Circular Array Technique and Implementation
    • Skip List Basics
    • BitMap Principles and Implementation

  • Implement Queue and Stack

    • Queue/Stack Basic
    • Implement Queue/Stack with Linked List
    • Implement Queue/Stack with Array
    • Deque Implementation

  • Implement HashMap

    • Basic Concept of HashMap
    • Implement HashMap with Separate Chaining
    • Key Points to Implement Linear Probing
    • Two Implementations of Linear Probing
    • Hash Set Basic and Implementation

  • Hash Table Variations

    • Use Linked List to Enhance Hash Table (LinkedHashMap)
    • Use Array to Enhance Hash Table (ArrayHashMap)
    • Bloom Filter Implementation

  • Binary Tree Structure and Traversal

    • Binary Tree Basic and Common Types
    • Binary Tree Recursive/Level Traversal
    • Use cases of DFS and BFS
    • N-ary Tree Recursive/Level Traversal

  • Binary Tree Variations

    • TreeMap Structure and Visualization
    • Red-Black Trees Basics and Visualization
    • Trie, Digital Tree, Prefix Tree Basics and Visualization
    • Basic Concept of Binary Heap
    • Binary Heap/Priority Queue Code Implementation
    • Segment Tree Basics and Visualization
    • Data Compression and Huffman Tree
    • Updating

  • Graph Structure and Algorithm Overview

    • Basic Terminology in Graph Theory
    • Graph Structure Code Implementation
    • Graph Structure DFS/BFS Traversal
    • Eulerian Graph and One-Stroke Game
    • Graph Shortest Path Algorithms Overview
    • Minimum Spanning Tree Algorithms Overview
    • Basic Concept of Union Find Algorithm
    • Updating

  • Implement and Visualize 10 Sorting Algorithms

    • Chapter Introduction
    • Key Metrics of Sorting Algorithms
    • Explore Selection Sort in Depth
    • Bubble Sort with Stability
    • Insertion Sort with Reverse Thinking
    • Shell Sort - Better than O(N^2)
    • Quick Sort and Binary Tree Preorder
    • Merge Sort and Binary Tree Postorder
    • Heap Sort and Binary Heap
    • Counting Sort: A New Pespective on Sorting
    • Bucket Sort
    • Radix Sort

  • Updating

• Chapter 0. Classic Problem Solving Templates
  • Chapter Introduction
  • How to Think About Data Structure and Algorithm
  • Two Pointer Techniques for Linked List Problems
  • Two Pointer Techniques for Array Problems
  • Sliding Window Algorithm Code Template
  • Thinking Recursion Algorithms from Binary Tree Perspective
  • One Perspective + Two Thinking Patterns to Master Recursion
  • Dynamic Programming Common Patterns and Code Template
  • Backtracking Algorithm Common Patterns and Code Template
  • BFS Algorithm Common Patterns and Code Template
  • Backtracking Algorithm to Solve All Permutation/Combination/Subset Problems
  • Greedy Algorithms Principles and Techniques
  • Divide and Conquer Principles and Techniques
  • Time and Space Complexity Analysis Practical Guide

• Chapter 1. Data Structure Algorithms

  • Linked List Algorithm

    • Two Pointer Techniques for Linked List Problems
    • Exercise: Two Pointer Techniques for Linked List
    • Tricks to Reverse a Linked List Recursively
    • How to Determine a Palindrome Linked List

  • Array Algorithm

    • Two Pointer Techniques for Array Problems
    • Match Three Game
    • Tricks to Traverse a 2D Array
    • Exercise: Two Pointer Techniques for Array
    • Game of Life
    • One Trick to Solve All N-Sum Problems
    • Prefix Sum Array Technique
    • Exercise: Prefix Sum Techniques
    • Difference Array Technique
    • Sliding Window Algorithm Code Template
    • Exercise: Sliding Window In Action
    • Sliding Window: Rabin Karp Algorithm
    • Binary Search Algorithm Code Template
    • Binary Search Follow-up
    • Binary Search in Action
    • Exercise: Binary Search Algorithm
    • Weighted Random Selection Algorithm
    • Advantage Shuffle Algorithm

• Stack/Queue Algorithm

  • Implement Stack with Queue, Implement Queue with Stack
  • Exercise: Stack Problems on LeetCode
  • Exercise: Bracket Problems on LeetCode
  • Exercise: Queue Problems on LeetCode
  • Monotonic Stack Code Template
  • Exercise: Monotonic Stack Problems on LeetCode
  • Monotonic Queue to Solve Sliding Window Problems
  • Exercise: Monotonic Queue Implementation and Leetcode Problems

• Binary Tree Algorithm

  • Thinking Recursion Algorithms from Binary Tree Perspective
  • Binary Tree in Action (Traversal)
  • Binary Tree in Action (Construction)
  • Binary Tree in Action (Post-order)
  • Binary Tree in Action (Serialization)
  • Binary Search Tree in Action (In-order)
  • Binary Search Tree in Action (Basic Operations)
  • Binary Search Tree in Action (Construction)
  • Binary Search Tree in Action (Post-order)

• Master Binary Tree Problems

  • Chapter Introduction
  • Exercise: Binary Tree Traversal I
  • Exercise: Binary Tree Traversal II
  • Exercise: Binary Tree Traversal III
  • Exercise: Binary Tree Divide and Conquer I
  • Exercise: Binary Tree Divide and Conquer II
  • Exercise: Binary Tree Combine Two Views
  • Exercise: Binary Tree Post-order I
  • Exercise: Binary Tree Post-order II
  • Exercise: Binary Tree Post-order III
  • Exercise: Binary Tree Level I
  • Exercise: Binary Tree Level II
  • Exercise: Binary Search Tree I
  • Exercise: Binary Search Tree II

• Binary Tree Follow-up

  • Lowest Common Ancestor All in One
  • Trick: How to Count Nodes in a Complete Binary Tree
  • Trick: Lazy Expansion of a Multiway Tree
  • Follow-up: Merge Sort Implementation and Applications
  • Follow-up: Quick Sort Implementation and Applications
  • Trick: Traverse Binary Tree with Stack

• Design Data Structures

  • Implementing LRU Cache like Building a Lego
  • Implementing LFU Cache like Building a Lego
  • How to Deleting Array Element in O(1) Time
  • Exercise: Hash Table Problems on LeetCode
  • Exercise: Priority Queue Problems on LeetCode
  • Implementing TreeMap/TreeSet
  • Basic Segment Tree Implementation
  • Dynamic Segment Tree Implementation
  • Lazy Update Segment Tree Implementation
  • Exercise: Segment Tree Problems
  • Implementing Trie Tree
  • Exercise: Trie Problems on LeetCode
  • Designing an Exam Room Algorithm
  • Exercise: Classic Design Problems on LeetCode
  • Implement Huffman Coding Compression
  • Implement Consistent Hashing Algorithm
  • How to Implement a Calculator
  • Implementing Median Algorithm with Two Binary Heaps
  • Removing Duplicates from an Array (Hard Version)

• Graph Algorithm

  • How to Determine a Bipartite Graph
  • Hierholzer Algorithm to Find Eulerian Path
  • Exercise: Eulerian Path
  • Cycle Detection Algorithm
  • Topological Sort Algorithm
  • Union-Find Algorithm
  • Exercise: Union-Find Problems on LeetCode
  • Dijkstra Algorithm
  • Dijkstra Algorithm with Restrictions
  • Exercise: Dijkstra Problems
  • A* Algorithm
  • Kruskal Minimum Spanning Tree Algorithm
  • Prim Minimum Spanning Tree Algorithm

• Chapter 2. Brute Force Search

  • DFS and Backtracking Algorithm

    • Backtracking Algorithm Common Patterns and Code Template
    • Backtracking in Action: Sudoku and N-Queens
    • Implement Sudoku Cheat
    • Backtracking Algorithm to Solve All Permutation/Combination/Subset Problems
    • Some Questions About Backtracking and DFS Algorithms
    • Solve All Island Problems with DFS
    • Minesweeper Game II
    • Ball and Box: Two Perspectives of Backtracking Enumeration
    • Backtracking Algorithm Practice: Generating Valid Parentheses
    • Backtracking Algorithm Practice: Partitioning k Subsets
    • Exercise: Backtracking Problems on LeetCode I
    • Exercise: Backtracking Problems on LeetCode II
    • Exercise: Backtracking Problems on LeetCode III

  • BFS Algorithm

    • BFS Algorithm Common Patterns and Code Template
    • Solve Maze Game
    • Huarong Road Game
    • Connect Two Game
    • Exercise: BFS Problems on LeetCode I
    • Exercise: BFS Problems on LeetCode II

• Chapter 3. Dynamic Programming Algorithms

  • Basic DP Techniques

    • Dynamic Programming Common Patterns and Code Template
    • How to Design Transition Equations
    • How to Determine the Base Case and Initial Values for Memoization?
    • Two Perspectives of Dynamic Programming Enumeration
    • How to Convert Backtracking to Dynamic Programming
    • Optimize Space Complexity for Dynamic Programming
    • Clarifying Some Questions About Dynamic Programming

  • Subsequence Problems

    • Classic DP: Edit Distance
    • DP Design: Maximum Subarray
    • Classic DP: Longest Common Subsequence
    • Subsequence Problem Patterns for DP

  • Knapsack Problems

    • Classic DP: 0-1 Knapsack Problem
    • Classic DP: Subset Knapsack Problem
    • Classic DP: Unbounded Knapsack Problem
    • A Variant of the Knapsack Problem: Target Sum

  • Dynamic Programming Game

    • Classic DP: Minimum Path Sum
    • Play Dungeon Game with DP
    • Play Freedom Trail with DP
    • Save Money on Your Trip: Weighted Shortest Path
    • Multi-source shortest path: Floyd algorithm
    • Classic DP: Regular Expression Matching
    • Classic DP: Egg Drop
    • Classic DP: Burst Balloons
    • Classic DP: Game Theory
    • One Method to Solve All House Robber Problems on LeetCode
    • One Method to Solve all Stock Problems on LeetCode

  • Dynamic Programming ProblemSet

    • Exercise: Rob House Pattern
    • Exercise: Knapsack Problems
    • Exercise: Dynamic Programming Problems I
    • Exercise: Dynamic Programming Problems II

  • Greedy

    • Greedy Algorithms Principles and Techniques
    • Two Approaches for Gas Station Problem
    • Greedy Algorithm for Interval Scheduling Problem
    • Scan Line Technique: Scheduling Meeting Rooms
    • Cut Video with a Greedy Algorithm

• Chapter 4. Other Common Techniques

  • Mathematical Techniques

    • LeetCode Problems with One Line Solution
    • Common Bit Manipulation Techniques
    • Essential Math Techniques
    • Minesweeper Game I
    • Random Algorithms in Games
    • Two Classic Factorial Problems on LeetCode
    • How to Efficiently Count Prime Numbers
    • How to Find Missing and Duplicate Elements
    • Interesting Probability Problems
    • Exercise: Math Tricks

  • Classic Interview Problems

    • How to Efficiently Solve the Trapping Rain Water Problem
    • One Article to Solve All Ugly Number Problems on LeetCode
    • One Method to Solve Three Interval Problems on LeetCode
    • Split Array into Consecutive Subsequences
    • Pancake Sorting Algorithm
    • String Multiplication Calculation
    • How to Determine if a Rectangle is Perfect

• More Topics

  • Computer Science

    • Frontend Development Introduction for AI Era
    • Introduction to Modern Encryption
    • Understand Session and Cookie
    • Understanding JSON Web Token (JWT)
    • Authentication vs. Authorization
    • Understanding OAuth 2.0 Authorization Framework
    • OAuth 2.0 and OIDC Authentication
    • OAuth 2.0 and PKCE
    • Understanding Single Sign-On (SSO)
    • Certificate and CA
    • TLS Key Exchange
    • Mutual TLS Authentication
    • Introduction to Linux File System
    • Linux Processes, Threads and File Descriptors
    • Pitfalls of Linux Pipeline
    • Linux Shell Tips
    • LSM Tree in Storage System
    • Updating

  • Design Pattern

    • Design Pattern: Singleton
    • Design Pattern: Factory Method
    • Design Pattern: Abstract Factory
    • Design Pattern: Builder
    • Design Pattern: Prototype
    • Design Pattern: Adapter
    • Design Pattern: Composite
    • Design Pattern: Decorator
    • Design Pattern: Bridge
    • Design Pattern: Observer
    • Design Pattern: Strategy
    • Updating