Introduction

What Can You Learn Here?

This site helps you develop a structured and templated way of thinking to solve algorithm problems. No matter your current skill level, this site can help you quickly reach a score of 85 out of 100.

Because the site teaches a templated and structured thinking mode, the 85 score you achieve is consistent and not dependent on luck. In other words, for problems with difficulty less than 85, you will definitely solve them. For problems with difficulty greater than 85, success might depend on inspiration and luck.

Reading Guide

For readers with time constraints (preparation time < 30 days), you can follow the order in the Quick Learning Plan.

For readers with a solid foundation (completed more than 300 problems), Chapter Zero is a must-read, and you can choose other chapters as needed.

For beginners, read through the site's directory in sequence, progressing steadily. The site is compatible with both PC and mobile devices:

Content of the Site

The site primarily offers three types of articles:

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

This is mainly covered in the chapter Rapid Introduction. This section explains the core principles and code implementation of sorting algorithms and classic data structures, generally without algorithm problems, focusing on foundational understanding.

2️⃣ Classic Algorithm Frameworks Explained with Examples (approximately 50% of the site's content)

For some classic algorithm frameworks or problems, I provide detailed explanations using entire articles and specific examples to help you understand the principles. Each article typically includes 2 to 5 example problems, which you can solve while reading.

3️⃣ Exercise Sections to Master Algorithm Frameworks (approximately 40% of the site's content)

Content marked with 【Intensive Practice】 in the directory belongs to the exercise section, usually following the algorithm framework content. Compared to examples, exercises focus on analogy and comprehensive understanding. I will guide you through numerous exercises to train your framework thinking, develop muscle memory, and fully master solving a type of problem. Each intensive practice contains about 10 exercises, which can be quickly solved once you grasp the framework thinking.

The site can help you solve over 500 free problems from LeetCode. Most of these problems are designed to practice framework thinking, meaning once you master a few core algorithm frameworks, you can solve them in minutes. You'll find that you've completed these problems almost effortlessly.

About This Site

Bookmark the latest address for continuous updates: labuladong.online

This site supports both mobile and PC viewing. For mobile devices, it is recommended to open directly in WeChat for easy one-click login.

With a structured approach, this site guides you through solving over 500 LeetCode problems, ensuring that the algorithmic thinking you develop remains sharp and can be quickly recalled even after years.

Click the magnifying glass icon at the top right of the site to search its content, supporting direct searches for LeetCode problems by English or Chinese name, problem number, or link.

The site is continuously updated and optimized, with "Update Log" and "Bug Feedback" links 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.

Practical Features of Our Site

1. Support for Algorithm Visualization Animations

All solution codes on our site and its accompanying plugins are equipped with an algorithm visualization panel, allowing you to intuitively observe the execution process and aid in understanding the algorithm logic. This visualization panel is located below the solution code for each problem.

For example, in the algorithm for Finding the Start of a Cycle in a Linked List, you can repeatedly click on the if (fast == slow) break; line to see the process of fast and slow pointers meeting. Similarly, clicking multiple times on the while (slow != fast) line will show how the pointers advance synchronously to meet at the start of the cycle:

The visualization panel also supports sorting algorithm visualization. For instance, here is the code for Insertion Sort. You can click the play button in the upper left corner to speed up the playback and observe the sorting process:

Recursive algorithms receive special enhancement in the visualization panel. For example, with the recursive solution of the Fibonacci sequence, you can continuously click on the if (n < 2) line to see the growth of the recursion tree:

The visualization panel significantly reduces the complexity of understanding intricate algorithms. For more details, please see Introduction to Visualization Panel.

2. Support for Reading History

In the sidebar, unread articles are marked with , articles read but not completed are marked with , and completed articles are marked with , making it easy for you to track your learning progress.

The same markers are used in reference links within articles, helping you identify whether you have studied the linked content.

3. Support for All Major Programming Languages

All solution codes on our site and its associated plugins support Java, C++, Python, Golang, JavaScript, and other popular programming languages to cater to a wide range of readers' needs.

The Java code is written by me, while the code in other languages is translated with the assistance of chatGPT but has been verified and debugged by me to ensure correctness and consistency.

4. Code Image Annotations

In our site and its associated plugins, complex code blocks include a light bulb icon. Hovering over this icon will display 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) {
            // 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

        }
    }
    if fast == nil || fast.Next == nil {
        return nil
    }
    slow = head

    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.