Introduction

If you want to get 85 points out of 100, no matter your current level, this site can help you reach that goal quickly.

We use template-based and framework-based thinking, so after learning here, you can always achieve this 85-point level stably, without relying on luck. This means if a problem’s difficulty is below 85, you can always solve it step by step. For harder problems, you may need inspiration or luck.

How to Read

If you are preparing for interviews, follow the order in the Quick Mastery Learning Plan.

If you have plenty of time (for example, you are still in school), you can just follow the site directory and study step by step.

This site works well on both PC and mobile. You can get all you need for algorithm interviews and coding tests in one place:

What’s on This Site

The site includes tutorials and video explanations, mainly in three parts:

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

Mostly in Data Structures and Sorting Explained. This part covers sorting algorithms and core data structure concepts and code implementation. No algorithm problems here. The goal is to help you understand how common data structures work, so you can use them right away when solving problems in the future.

2️⃣ Algorithm Frameworks Explained With Examples (about 50%)

Some famous algorithm frameworks and typical problems are explained step by step with sample problems. Usually, one article covers 2–5 examples, so you can practice as you read.

3️⃣ Practice Problems for Frameworks (about 40%)

Chapters labeled Exercise are exercise parts, usually right after the framework content. All these problems can be solved using the frameworks. Doing many exercises will help you build muscle memory and master certain types of problems. Each practice session has 5–10 exercises, and once you know the framework, they are quick to solve.

This site helps you solve hundreds of public LeetCode problems. Most problems are for practicing these frameworks, and will be easy to solve in minutes after learning.

LeetCode Problem List

By request, I created a problem list that covers all problems on this site. After installing the Chrome Extension, you can see the site’s solution notes for every problem on this list.

Note: I don't think this problem list is very important, so I don’t suggest using it directly. The list is in a random order, so you won’t learn step by step or by topic. Also, you don’t need to do every problem. Once you’ve learned the frameworks here, most questions can be solved quickly, so you don’t need to force yourself to do every one.

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

It is better to follow the Beginner Learning Plan or Quick Mastery Learning Plan, which have structured lists. The VSCode extension and Jetbrains extension also have these plans built in — for your convenience.

I care about your learning experience. The content here is always being updated and improved. You can find update logs and bug feedback links at the top.

About the Author

I’m labuladong, the author of the fucking-algorithm repo. Readers call me “Dong Ge”. I created the framework way of thinking about algorithms. My repo has been at the top of GitHub Trending many times and now has 125k stars.

My focus is quality over quantity. This site only focuses on helping you master coding problems for interviews and contests, efficiently and quickly.

Site subscription is the only paid feature. Pay one meal’s worth to unlock all content and tools, and enjoy smooth, easy learning.

Useful Features of This Site

Quick Mastery Roadmap

This site offers an Algorithm Quick Mastery Plan with a learning roadmap. You can click each node to see related articles and problem lists, making it easy to track your learning progress.

Algorithm Visualization

Every solution code on this site and all related plugins comes with an algorithm visualization panel. You can see how the algorithm runs, which helps you understand the logic.

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

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.

Learn by Playing Games

The visualization panels help you see how algorithms work, but only solving problems can get boring. I want to connect algorithms with real life to make them more fun and help you really enjoy learning algorithms.

One idea is to combine algorithms with games. Usually, we control games by hand, but what if you could use algorithms to control a game?

So, I designed some classic mini-games. In each game, the algorithm part is separated out. You'll get a game scene, and you write the algorithm to let the game engine run. You can make the game work, or finish some tasks that are hard by hand.

This way, you get a great sense of achievement. More importantly, you learn how algorithms are used in real situations, and your understanding will be deeper.

For example, here is a Snake game. You can write code for the snake’s movement and eating food. It might look hard, but it’s easy if you use basic singly linked list operations:

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

Supports All Mainstream Programming Languages

All solution code on this site and all plugins support Java, C++, Python, Golang, JavaScript, and other common languages. This makes it easier for everyone.

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

The site and plugins also support code image annotations. For complex code, there will be a small light bulb icon. Move your mouse over it to see the image for extra help:

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

Reading History Supported. In the sidebar and in every article, articles you have not read show the icon. Articles you have read but not finished show the icon. Finished articles show the icon. This helps you track your learning progress. Reading history syncs across all your devices.

Focus Mode Supported. On computer, there is a "Focus Mode" switch at the top right of the page. Turn it on to blur the sidebar and top bar, making it easier to focus or to study at work.

Full Site Search Supported. The search box at the top right lets you search the whole site. You can even search by problems, numbers, or LeetCode links to find explanations.

Coding Practice Plugins for Learning

To meet everyone’s needs, I maintain plugins so you can practice coding in your favorite editor.

The plugins include the Beginner Directory and Quick Mastery Directory. You can debug code locally and easily view ideas, visual panels, and code image notes from this site.

You don't have to install the plugins, but I suggest installing the Chrome browser plugin. When you read articles here, you may visit LeetCode. The Chrome plugin gives you some extra tools. The vscode/Jetbrain plugins can also be installed if you like.

To see the install guides, check Chrome Plugin, vscode Plugin, Jetbrain Plugin.