Introduction

If the full score is 100, our site can help you quickly reach a score of 85, no matter your current level.

Because we teach a template and framework-based way of thinking, the 85 points you achieve here are stable and repeatable, not relying on luck. This means you can always solve problems with difficulty below 85, step by step. For problems harder than 85, creativity and luck matter more.

How to Read

If you are preparing for interviews or written tests, follow the Quick Mastery Plan step by step.

If you are a beginner with more time (like a student), just follow the sequence of this site slowly and steadily.

Our site works well on both PC and mobile. You can master all algorithm interview and written tests in one place:

Site Content

The tutorials include both written and video guides, mainly divided into three parts:

1️⃣ Data Structures Guide (about 10% of content)

This is mainly in Data Structures and Sorting. We explain sorting algorithms and the core logic of classic data structures. There are no real problems here—just learn the basic ideas and how to code them. You’ll use these as a foundation in real problems and interviews.

2️⃣ Classic Algorithm Frameworks with Examples (about 50% of content)

For classic algorithms, I use detailed articles and real problem examples to help you understand the logic. Each article usually has 2 to 5 example questions that you can solve as you learn.

3️⃣ Exercises for Practice (about 40% of content)

Parts marked Exercise are exercises, usually right after the algorithm frameworks. These exercises can all use the frameworks directly. Doing them builds muscle memory so you really master a problem type. Each practice article has 5 to 10 questions—after getting the framework, you can solve them much faster.

We help you solve hundreds of free LeetCode problems. Most are for framework practice. Once you know the frameworks, you can quickly finish them and complete all the problems without much effort.

LeetCode Problem List

For convenience, I made a list of all problems covered on this site. After installing the Chrome Extension, you can see my tagged solutions on the list.

But honestly, I don't suggest using this list as your main way to practice. The order is random, and you can’t learn step by step or focus on specific topics. Also, you don’t need to solve every problem. Once you master the frameworks, most problems become very easy.

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

I recommend following the Beginner Study Plan or Quick Mastery Study Plan on this site. Both plans have categorized problem lists. The VSCode Extension and Jetbrains Extension also include these study plans to help you.

I care about your learning experience, and always update and improve the content. There are Update Logs and Bug Report links at the top.

About the Author

I am labuladong, author of the fucking-algorithm repo. Readers call me "Dong Ge". I created framework-based algorithm solving. My repo has been a top trend on GitHub, with over 125k stars now.

My style is focused: I only target algorithm problem-solving. I make sure you master algorithms quickly and efficiently.

Subscribe to the site is the only paid service. One meal's cost unlocks all content and tools and gives you the best learning experience.

Useful Features of This Site

Quick Mastery Roadmap

This site offers a Quick Algorithm Mastery Roadmap with a matching learning path. Click each node to see related articles and question lists. It helps you track your learning progress.

Algorithm Visualization

All solutions on this site and in its plugins come with a set of algorithm visual panels under the code. You can clearly see how the algorithm runs, which helps in understanding the logic.

The visual panels can show data structures in different ways for better understanding.

For example, the array below looks like a bar chart to show how Insertion Sort works. Click if (nums[i] < nums[i - 1]) to see the sorting process step by step:

These panels can make it much easier to understand hard algorithms. They support all data structures and algorithms; only a few are shown here. You can find more visualizations on the Algorithm Visualization Quick Reference Page.

Learn Algorithms Through Games

Visualization helps you understand algorithms better, but just solving problems can get boring. I want to make learning fun by connecting algorithms with real life, so you can truly enjoy studying algorithms.

One idea is to mix algorithms with games. Usually, you play games with your hands, but can you use algorithms to control the game instead?

So, I have designed some classic mini-games. I break the game into algorithm parts. You write code to let the game engine play, complete a task, or beat a hard level.

This not only gives you a big sense of achievement, but you will also see how algorithms work in real scenarios and understand them better.

For example, here is a Snake game. You are asked to write the move and eat logic to let the snake play. It may look hard, but it's simple if you use basic operations on a singly linked list:

You can find more fun games in Play and Summary of Algorithm Games.

Supports All Popular Programming Languages

All solution codes on this site and in its plugins support Java, C++, Python, Golang, JavaScript, and other common programming languages, so most readers can find their language.

I have checked and debugged the code in every language, making sure each is correct and consistent.

You can see code image annotations for complex blocks. When you see a small light bulb icon, hover your mouse over it, and you will see an image to help you understand:

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 is supported. In the sidebar and inside articles, a link before an unread article will have ; a link before a read but unfinished article will have ; and before a finished article, you'll see . This helps you know your progress. The reading history is auto synced to all devices.

Focus mode is supported. On desktop, the upper right corner has a "Focus Mode" switch. Turn it on to blur the sidebar and header so you can focus or study privately at work.

Full-site search is supported. The search box on the upper right supports searching the whole site. You can search LeetCode questions, numbers, or links to go directly to their solution.

Coding Practice Plugins

To meet all needs, I have developed plugins for practicing questions. These can let you practice inside your favorite code editor, making studying easier.

The plugins include the Beginner's Directory and the Quick Mastery Directory. They also support local code debugging, viewing site explanations, visualization panels, image tips, and other features.

You do not have to install these plugins, but I suggest you add the Chrome browser plugin. When you visit this site, you may open LeetCode a lot, and the Chrome plugin gives good help. The vscode and Jetbrain plugins are for your coding habits.

See guides for each plugin here: Chrome Plugin, vscode Plugin, Jetbrain Plugin.