Introduction

If the full score is 100, regardless of your foundation, this site can help you reach a level of 85 in the shortest time possible.

Because this site teaches a templated, structured way of thinking, the 85 score you achieve is stable and repeatable, independent of luck. This means for problems with difficulty less than 85, you can solve them methodically, and for those with difficulty greater than 85, inspiration and luck are needed.

Reading Approach

For readers with urgent time constraints (preparation time < 30 days), follow the order in the Quick Mastery Plan.

For readers with some foundation (solved > 300 problems), Chapter 0 is a must-read; other chapters can be selected as needed.

For beginners, read according to the site's directory in a steady manner. The site is compatible with both PC and mobile:

Site Content

The site offers tutorials with pictures and videos, mainly divided into three categories:

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

Mainly focused in Introduction to Data Structures and Sorting. This section explains sorting algorithms and the core principles and code implementations of classic data structures. It generally doesn't include algorithm problems and aims to help readers understand the principles of commonly used data structures at work and those unique to algorithm problems, which can be directly applied in future tasks.

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

For some classic algorithm frameworks or problems, I will use entire articles to explain them in detail with specific examples to help you understand the principles. Generally, each article includes 2-5 examples that you can solve as you read.

3️⃣ Exercise Chapters to Help You Master Algorithm Frameworks (about 40% of site content)

Content marked with 【Exercise】 in the directory belongs to the exercise section, usually following the algorithm framework content. Exercises are problems that can directly apply frameworks, aiming to help you develop muscle memory through repetition and thoroughly master a type of problem-solving method. Each intensive practice includes 5-10 exercises, allowing you to solve them quickly after mastering the algorithm framework.

This site can guide you through solving hundreds of free LeetCode problems. Most of these problems are for practicing framework thinking, and once you master the algorithm frameworks, they can be solved in minutes, finishing them all unconsciously.

About the Site

Keep up with the latest address of our site, continuously updated: labuladong.online

The site supports both mobile and PC reading, and it's recommended to open it directly in WeChat on mobile for easy one-click login.

The site guides you through solving hundreds of free LeetCode problems with a framework mindset, ensuring that your algorithmic thinking won't degrade and can be quickly regained even after years.

I highly value everyone's learning experience and continuously update and optimize the site's content. There is an Update Log and a Bug Feedback link at the top.

LeetCode Problem List

At the request of some readers, I compiled a list of problems covered on the site. After installing the Chrome Plugin, you can open this list to see that all problems have site-provided solutions/ideas.

However, please note that I personally think this list is not very useful and do not recommend practicing directly from it because the problem order is random, making it hard to learn progressively or focus on specific topics. And it's unnecessary to complete all these problems; once you master the core algorithm framework, most problems can be solved quickly without deliberate practice:

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

I suggest following the Beginner's Learning Plan or Quick Mastery Learning Plan for structured learning. These plans include categorized problem lists, and the VSCode Plugin and JetBrains Plugin integrate these learning plans for convenient use by readers in need.

About the Author

I am labuladong, the author of the fucking-algorithm repository, commonly referred to as "Dong Ge" by readers. I pioneered the framework thinking approach to problem-solving and have topped GitHub Trending multiple times, currently with over 125k stars.

My personal style focuses on being small and precise, not large and comprehensive, so the site targets only algorithm problem-solving, hitting the mark accurately to help readers master algorithms thoroughly in the shortest time possible.

Site Subscription is the only paid project, allowing access to all site content and tools with the cost of a meal, providing the smoothest learning experience.

Practical Features of the Site

1. Supports Algorithm Visualization

All solutions in this site and its accompanying plugins are equipped with an algorithm visualization panel underneath the code, allowing for an intuitive view of the algorithm's execution process, aiding in understanding the logic.

The visualization panel can present data structures in various forms, facilitating readers' understanding.

For example, below is an array represented as a histogram, demonstrating the Insertion Sort process. You can click the play button in the upper left corner to speed up playback and view the sorting process:

The visualization panel significantly reduces the effort required to understand complex algorithms, supporting all data structures and algorithms, with only a few examples shown here. More classic algorithm visualizations can be found on the Algorithm Visualization Quick Reference Page.

2. Combine with Game Engines for Practical Application

The visualization panel allows readers to intuitively grasp the execution process of algorithms. However, merely practicing problems can be monotonous, so I aim to connect algorithms with real life to further showcase their charm and foster a genuine interest in algorithms.

One idea is to integrate algorithms with games. Instead of using hands to play games, can algorithms be used to operate them?

Thus, I will design classic mini-games, abstracting their algorithmic components, providing a game scenario for readers to write algorithms for the game engine to execute, ultimately resulting in a playable game or completing a challenging task.

This approach not only gives readers a strong sense of accomplishment but also provides insight into the application of algorithms in real-world scenarios, leading to a deeper understanding.

For example, below is a snake game where you write the logic for the snake's movement and food consumption to make the game run. While it may seem complex, it can be achieved using Basic Operations of Singly Linked Lists:

The gaming feature is still in the beta stage; I have several game ideas that will be gradually released on the website.

3. Supports All Major Programming Languages

All solution codes on this site and its accompanying plugins support common programming languages such as Java, C++, Python, Golang, and JavaScript, catering to a wide range of readers.

The Java code is written by me, while other languages are assisted by chatGPT, all of which have been personally verified and debugged to ensure correctness and consistency.

The site and plugins support code image annotations. For complex code blocks, a lightbulb icon may appear, and hovering over it will reveal an image to aid understanding:

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
        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
        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
        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
    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
    while (slow !== fast) {
        fast = fast.next;
        slow = slow.next;
    }
    return slow;
};

4. Other Practical Features

Supports Reading History. In the sidebar and within articles, unread articles display an mark, articles read but not completed show an mark, and completed articles display an mark, allowing you to track your learning progress. Reading history is automatically synced across all devices.

Supports Focus Mode. When accessing the site on a computer, a "Focus Mode" switch is available in the upper right corner. Enabling it blurs the sidebar and top bar, helping to concentrate attention or learn discreetly at work.

Supports Site-wide Search. The search box in the upper right corner supports site-wide search, allowing you to search for explanations by entering LeetCode problems, titles, or links.

5. Accompanying Problem-Solving Plugins for Learning

To cater to different readers' needs, I have developed and maintained problem-solving plugins for the site, enabling readers to practice problems in their preferred code editor, facilitating leisure learning.

The problem-solving plugins integrate Beginner's Directory and Quick Mastery Directory, support local code debugging, and provide easy access to the site's thought process explanations, visualization panels, image annotations, and other practical features.

The problem-solving plugins are not mandatory, but I recommend installing the Chrome browser extension because you may frequently switch to LeetCode pages while reading the site, and the Chrome extension can offer some assistance. You can choose to install the vscode/Jetbrain plugins based on your problem-solving needs.

For installation and usage of the various problem-solving plugins, see Chrome Plugin, vscode Plugin, and Jetbrain Plugin.