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

1. Algorithm Visualization

On this site and in all related plugins, there is an algorithm visualization panel below each solution code. You can see how the algorithm works step by step. This helps you understand the logic of the algorithm.

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

For example, below is an array shown as a bar chart. It shows the steps of Insertion Sort. You can click the play button in the top left to speed up and watch the sorting process.

The visualization panel makes it much easier to understand complex algorithms. It supports all data structures and algorithms. Here are just a few examples. For more classic algorithm visualizations, see the Algorithm Visualization Quick Reference.

2. Learn and Apply Algorithms with Game Engines

The visualization panel helps you see how algorithms work. But just solving problems is not enough. I want to help you use algorithms in real life, and show the fun side of algorithms, so you will truly enjoy learning them.

One of my ideas is to combine algorithms and games. Usually, we play games with our hands, but can we use algorithms to play games instead?

So, I have designed some classic small games. I separate the algorithm parts and give you a game scene. You can write algorithms to control the game engine. In the end, you get a running game or complete a game task (which would be hard to do by hand).

This way, you can get a strong sense of achievement. More importantly, you can see how algorithms are used in real scenarios and understand them better.

For example, here is a Snake game. You can write code for the snake's movement and how it eats food. The game will run using your code. It may seem hard at first, but it is simple if you use basic linked list operations:

For more fun games, see Algorithm Games and Summary.

3. Supports All Popular Programming Languages

All solution codes on this site and in all plugins support all common programming languages, including Java, C++, Python, Golang, JavaScript, and more. This is to help as many readers as possible.

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

The site and plugins also support code image notes. For complex code, there is a small lightbulb icon. Move your mouse over the lightbulb to see helpful images.

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;
};

4. Other Useful Features

Reading history is supported. In the sidebar and inside articles, links to unread articles show a icon. Articles you have read but not finished show a icon. Finished articles show a icon. This helps you track your learning progress. Your reading history syncs across all devices.

Focus mode is supported. When you visit the site on a computer, there is a "Focus Mode" switch at the top right. Turn it on to blur the sidebar and top bar. This helps you focus or learn at work.

Site-wide search is supported. The search box at the top right lets you search the whole site. You can also enter a LeetCode problem, number, or link to find the explanation directly.

5. Helpful Plugins for Practicing Problems

To meet different needs, I have developed plugins for this site. You can use them to practice coding in your favorite editor, and slack off at work.

The plugins include the Beginner Directory and Quick Mastery Directory. You can debug code locally, and easily see explanations, visual panels, image notes, and more.

The plugins are not required, but I suggest installing the Chrome browser plugin. When you read this site, you may often jump to LeetCode to practice. The Chrome plugin can help you. The vscode/Jetbrain plugins can be installed if you want to practice in those editors.

See Chrome Plugin, vscode Plugin, and Jetbrain Plugin for how to install and use each plugin.