Introduction

If the full score is 100, no matter your background, this site can help you reach a score of 85 in the shortest time.

This is because the site teaches you to use templates and frameworks. You can always get to this 85 by following the methods here. For problems below 85 in difficulty, you can solve them step by step. Only for problems harder than 85, you need luck and inspiration.

How to Read

If you have little time and need to quickly prepare (less than 30 days), follow the Quick Mastery Plan.

If you already have some experience (solved more than 300 problems), you must read Chapter 0. You can choose other chapters as needed.

If you are a beginner, read in order, step by step, following the site structure.

This site works well on both PC and mobile. You can prepare for algorithm interviews and written tests all in one place.

About the Content

The content includes both written tutorials and videos, mainly divided into three parts:

1️⃣ Data Structure Tutorials (about 10% of the site)

Focused in Data Structures and Sorting. These teach sorting and key data structures, with explanations and code. This part does not have algorithm problems. It helps you understand common data structures for work and special ones used in algorithm problems, so you can use them when solving problems later.

2️⃣ Classic Algorithm Frameworks Explained with Examples (about 50% of the site)

For classic algorithm frameworks or problems, I write whole articles to explain with real examples. The goal is to help you understand the idea. Each article usually has 2-5 example problems. You can solve them as you read.

3️⃣ Exercise Chapters to Practice Frameworks (about 40% of the site)

Chapters marked Practice are for practice. They come right after the framework explanations. All practice problems can use the taught frameworks directly. The goal is to help you build muscle memory by repeating. Each exercise has 5-10 problems. Once you understand the framework, you can solve them quickly.

This site helps you solve hundreds of free LeetCode problems. Most are for practicing the frameworks. Once you get the method, you can solve them in minutes.

LeetCode Problem List

Some readers asked for a list of all problems covered on this site. After installing the Chrome extension, you can open the list to see all problems with solution notes from this site.

But, I think this list is not very useful and I do not suggest practicing by this list. The order is random, you can't learn step by step, and can't focus on a certain topic. You also don't need to finish all these problems. Once you master the frameworks, most problems become easy and do not need extra practice.

LeetCode China	LeetCode Global
https://leetcode.cn/problem-list/59jEaTgw/	https://leetcode.com/list/9zwo3ww5/

I suggest following the Beginner Plan or the Quick Mastery Plan, which have organized lists by topic. The VSCode extension and Jetbrains extension also include these plans for easy access.

I care a lot about your learning experience and keep updating and improving the content. At the top, you can find update logs and bug feedback.

About the Author

I am labuladong, author of the fucking-algorithm repo. Readers usually call me "Dong Ge". I created the framework thinking method for solving problems. My repo often tops GitHub Trending and has over 125k stars.

I focus on making things simple and to the point. This site is only for algorithm practice, helping you master algorithms quickly and efficiently.

Site subscription is the only paid feature. For the price of a meal, you can unlock all tutorials and tools on this site and enjoy a smooth learning experience.

Useful Features of This Site

Quick Learning Roadmap

We provide an Algorithm Quick Mastery Plan with a clear learning roadmap. Click each node to see related articles and problem lists. This helps you easily track your learning progress.

Algorithm Visualization

Every solution on this site and all our plugins comes with an algorithm visualization panel under the code. You can see how the algorithm works step by step, which helps you understand the logic better.

The visualization panel can show data structures in different ways to help readers understand them.

For example, it uses a bar chart to show the array during insertion sort. You can click the play button at the top left to speed up and watch the sorting process.

The visualization panel helps you understand complex algorithms much easier and supports all data structures and algorithms. Here we only show a few examples. You can see more classic algorithm visualizations on the Quick Visualization Reference Page.

Learn by Playing Games

Visualization helps you see how algorithms work. However, just practicing problems may feel boring. I want to connect algorithms with real life, so you can truly enjoy learning algorithms.

One idea is to combine algorithms with games. We usually use our hands to play games, but can we use algorithms to control the game?

So, I designed some classic mini games where I separate the algorithm module. You are given a game scene and asked to write code to control the game engine, so you can finish the game or complete a task that is hard to do manually.

This gives you a strong sense of achievement and helps you see how algorithms are used in real scenarios.

For example, here's a snake game. Try writing the logic to move the snake and eat food. It may seem hard at first, but it's actually easy if you use basic linked list operations:

For more fun mini games, see Algorithm Games List and Introduction.

Support for All Popular Programming Languages

All solution code on this site and all plugins support Java, C++, Python, Golang, JavaScript, and other common languages. This helps more readers with different language needs.

All code has been tested and debugged by me to make sure it is correct and consistent.

The site and all plugins also support code image annotations. For complex code, you will see a light bulb icon. Hover your mouse on it to see an image to help understand the code.

class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast, slow;
        fast = slow = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow) break;

        }
        // the above code is similar to the hasCycle function
        if (fast == null || fast.next == null) {
            // fast encountering a null pointer means there is no cycle
            return null;
        }

        // reassign to the head node
        slow = head;

        // move fast and slow pointers at the same pace, the
        // intersection point is the cycle's entry point
        while (slow != fast) {
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
}

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast, *slow;
        fast = slow = head;
        while (fast != nullptr && fast->next != nullptr) {
            fast = fast->next->next;
            slow = slow->next;
            if (fast == slow) break;

        }
        // the above code is similar to the hasCycle function
        if (fast == nullptr || fast->next == nullptr) {
            // if fast encounters a null pointer, it means there is no cycle
            return nullptr;
        }

        // reset to the head node
        slow = head;

        // move the fast and slow pointers forward in sync, the
        // intersection point is the start of the cycle
        while (slow != fast) {
            fast = fast->next;
            slow = slow->next;
        }
        return slow;
    }
};

class Solution:
    def detectCycle(self, head: ListNode):
        fast, slow = head, head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                break

        
        # the above code is similar to the hasCycle function
        if not fast or not fast.next:
            # if fast encounters a null pointer, it means there is no cycle
            return None
        
        # reset the pointer to the head node
        slow = head 

        # both fast and slow pointers move forward in sync, the
        # intersection point is the start of the cycle
        while slow != fast:
            fast = fast.next
            slow = slow.next
        return slow

func detectCycle(head *ListNode) *ListNode {
    fast, slow := head, head
    for fast != nil && fast.Next != nil {
        fast = fast.Next.Next
        slow = slow.Next
        if fast == slow {
            break

        }
    }
    // the above code is similar to the hasCycle function
    if fast == nil || fast.Next == nil {
        // if fast encounters a null pointer, it means there is no cycle
        return nil
    }
    // reset the pointer to the head node
    slow = head

    // move the fast and slow pointers forward in sync,
    // the intersection point is the start of the cycle
    for slow != fast {
        fast = fast.Next
        slow = slow.Next
    }
    return slow
}

var detectCycle = function(head) {
    let fast, slow;
    fast = slow = head;
    while (fast !== null && fast.next !== null) {
        fast = fast.next.next;
        slow = slow.next;
        if (fast == slow) break;

    }
    // the above code is similar to the hasCycle function
    if (fast === null || fast.next === null) {
        // if fast encounters a null pointer, it means there is no cycle
        return null;
    }

    // reset the pointer to the head node
    slow = head;

    // move the fast and slow pointers forward in sync,
    // the intersection point is the start of the cycle
    while (slow !== fast) {
        fast = fast.next;
        slow = slow.next;
    }
    return slow;
};

Other Useful Features

Supports reading history. In the sidebar and all articles, articles you have not read are marked with . Articles you've read but not finished have . Finished articles have . This helps you track your learning progress. Your reading history is automatically synced on all devices.

Supports focus mode. On desktop, there's a "Focus Mode" switch at the top right. When turned on, it will blur the sidebar and top bar. This helps you focus, or makes it easier to learn when you're at work.

Supports site-wide search. The search box at the top right can search the whole site. You can enter LeetCode problems, problem numbers, or links to find explanations directly.

Practice Plugin to Help Learning

To meet the needs of different readers, I have developed plugins for practicing problems, so you can practice in your favorite code editors. It's also good for sneaky practice at work.

The plugin includes the Beginner's Catalog and Quick Mastery Catalog, supports local code debugging, and lets you view solution explanations, visualization panels, and code image annotations easily.

The practice plugin is not required, but I suggest installing the Chrome plugin. When reading this site, you may jump to LeetCode pages to practice. The Chrome plugin gives you extra help. You can also install vscode or Jetbrain plugins as needed.

For installation details of each practice plugin, see Chrome Plugin, vscode Plugin, and Jetbrain Plugin.