Introduction

Utility of This Site

This site helps you develop a structured and templated approach to solving algorithm problems. Regardless of your starting point, you can improve your skills to an 85 out of 100 score in the shortest possible time.

Since the site teaches a templated, structured thinking pattern, achieving this score of 85 is consistent and not reliant on luck. In other words, you will definitely solve problems with a difficulty level below 85, while those above 85 may require some inspiration and luck.

Reading Guide

For readers with limited time (preparation time < 30 days), you may follow the sequence in the Quick Learning Plan.

For readers with some foundation (completed over 300 problems), Chapter Zero is a must-read, while other chapters can be chosen based on your needs.

For beginners, follow the sequence of the site’s directory for a solid understanding. The site is compatible with both PC and mobile devices:

Content of the Site

The site mainly consists of three types of articles:

1️⃣ Basic Tutorials on Data Structures (comprising about 10% of the site's content)

This is mainly concentrated in the chapter on Detailed Explanation of Data Structures and Sorting. This section explains the core principles and code implementations of sorting algorithms and classic data structures. It generally does not include algorithm problems. The primary aim is to help readers understand the principles of data structures commonly used in work and those unique to algorithm problems, allowing you to apply them directly in the future.

2️⃣ Detailed Explanation of Classic Algorithm Frameworks with Examples (comprising about 50% of the site's content)

For some classic algorithm frameworks or problems, I provide comprehensive articles combining specific examples for detailed explanations, aiming to help you understand the principles. Typically, each article contains 2-5 example problems, which you can solve as you read.

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

Content marked with 【Enhanced Practice】 in the directory belongs to the exercise section, generally following the algorithm framework content. The exercises are problems that can be directly applied to the framework, aiming to help you develop muscle memory through repeated practice and thoroughly grasp the solution of a type of problem. Each enhanced practice contains about 10 exercises, and once you master the algorithm framework, you can solve them quickly.

The site can guide you in solving 500+ freely available problems on LeetCode. Most of these problems are for practicing framework thinking. As long as you master a few core algorithm frameworks, you can solve them in minutes, completing all these problems almost effortlessly.

About This Site

Bookmark the latest address for continuous updates: labuladong.online

This site supports both mobile and PC reading. It is recommended to open the site directly within WeChat on mobile for easy one-click login.

This site can guide you step-by-step through solving over 500 LeetCode problems, and the algorithmic thinking you develop will remain sharp, allowing you to quickly regain problem-solving skills even years later.

Click the magnifying glass icon in the upper right corner of the site to search its contents. You can search for LeetCode problems by title, number, and link in both English and Chinese.

The site is continuously updated and optimized. There are links for "Update Log" and "Bug Feedback" at the top.

About the Author

I am labuladong, the author of the fucking-algorithm repository. Readers often call me "Dong Ge." I pioneered the framework-thinking approach to problem-solving and have frequently topped the GitHub Trending list, currently earning 125k stars.

My goal is to create the best algorithm tutorial, focusing on being concise and precise rather than comprehensive; striving to help readers master algorithms, a notoriously difficult subject, in the shortest time possible.

This site's subscription is the only paid service offered, and for the cost of a meal, you can unlock all content and tools on the site, ensuring a smooth and seamless learning experience.

Useful Features of the Website

1. Support for Algorithm Visualization Animations

On this website and all associated plugins, every solution code is accompanied by an algorithm visualization panel, allowing you to intuitively observe the execution process of the algorithm and aiding in understanding its logic.

The visualization panel significantly reduces the complexity of understanding algorithms, supporting all data structures and algorithms. These are just a few examples. More classic algorithm visualizations can be found on the Algorithm Visualization Quick Reference Page.

2. Support for Reading History

In the sidebar and within all articles, links to unread articles are marked with , articles read but not completed are marked with , and completed articles are marked with , helping you track your learning progress.

Reading data is automatically synchronized across all devices.

3. Support for All Major Programming Languages

This website and all associated plugins support solution codes in all common programming languages such as Java, C++, Python, Golang, and JavaScript, catering to the needs of a broad audience.

Java code is written by me, while codes in other languages are translated with the assistance of chatGPT but have been personally verified and debugged by me to ensure accuracy and consistency.

4. Code Image Annotations

This website and all associated plugins feature a light bulb icon next to more complex code blocks. Hovering over the icon will display images 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) {
            // if fast encounters a null pointer, it means there is no cycle
            return null;
        }

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

Complementary Problem-Solving Plugin

To cater to the diverse needs of readers, I have developed and maintained a complementary problem-solving plugin for this site, allowing users to practice coding in their preferred code editors, even during leisure time.

Within the problem-solving plugin, all exercises explained on this site have special enhancements. You can access short insights or detailed solutions, and use all practical features of this site, such as visualization panels and annotated images.

The problem-solving plugin is not mandatory to install, but I recommend the Chrome browser plugin. This is because while reading this site, you may frequently navigate to LeetCode/力扣 for practice, and the Chrome plugin can provide some assistance. You can choose to install the vscode/Jetbrain plugins based on your personal problem-solving needs.

For detailed installation and usage instructions for each plugin, refer to Chrome Plugin, vscode Plugin, and Jetbrain Plugin.