Introduction

Purpose of This Site

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

The site teaches a templated and structured way of thinking, so the 85 score you achieve is consistent and not reliant on luck. In other words, you will definitely be able to solve problems with a difficulty level below 85, while those above 85 might require inspiration and luck.

Reading Guide

For readers who are in a hurry (preparation time < 30 days), follow the sequence in the Quick Mastery Plan.

For readers with some background (more than 300 problems practiced), the content of Chapter Zero is a must-read, while other chapters can be chosen as needed.

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

Content of the Site

The site mainly features three types of articles:

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

Focus on the chapter Detailed Explanation of Data Structures and Sorting. This part explains the core principles of sorting algorithms and classic data structures, and their code implementations. It generally does not include algorithm problems. The main purpose is to let readers understand the principles of commonly used data structures in work and the principles and usage scenarios of unique data structures in algorithm problems, allowing direct application in future problem-solving.

2️⃣ Explanation of Classic Algorithm Frameworks with Example Problems (about 50% of the site's content)

For some classic algorithm frameworks or problems, I will provide detailed explanations with entire articles combined with specific example problems to help you understand the principles. Each article generally includes 2~5 example problems that you can solve as you read.

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

Content marked with 【Exercise】 in the directory belongs to the exercise section, usually following the algorithm framework content. The exercises are problems that can directly apply the framework, aimed at helping you build muscle memory through a lot of repetition, thoroughly mastering the solution to a type of problem. Each exercise includes about 10 problems, which can be solved quickly after mastering the algorithm framework.

The site can help you solve hundreds of publicly free LeetCode problems. Most of these problems are for practicing framework thinking. Once you master several core algorithm frameworks, you can solve them in a few minutes, completing them all without even noticing.

About This Site

Keep track of the latest updates at: labuladong.online

This site supports both mobile and PC reading. For mobile, it is recommended to open directly in WeChat for easy login.

This site offers hands-on guidance to help you solve hundreds of free public LeetCode problems. The algorithmic thinking developed here will not degrade and can be quickly regained even years later.

I place great emphasis on the learning experience of users and continuously update and optimize the content. The top of the page features Update Log and Bug Feedback sections.

LeetCode Problem List

At the request of some readers, I compiled a list of all problems covered on this site. After installing the Chrome Extension, you can access this list and see problem solutions and ideas marked on the site.

However, please note that I personally think this list is not very useful, and I do not recommend solving problems directly from it. The problem order is random, and it does not allow for gradual learning or targeted study of specific knowledge points. Moreover, you do not need to complete all these problems; once you learn the core algorithm framework, most problems can be solved quickly without deliberately practicing:

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

I recommend following the Beginner's Learning Plan or the Quick Mastery Learning Plan for structured learning. These plans include categorized problem lists, and both the VSCode Extension and Jetbrains Extension integrate these learning plans to facilitate user access.

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 This Site

1. Supports Algorithm Visualization

All solution codes on this site and in all accompanying plugins come with an algorithm visualization panel. This feature allows you to visually observe the execution process of algorithms, aiding in understanding their logic.

The visualization panel significantly reduces the complexity of understanding algorithms and supports 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. Supports Reading History

In the sidebar and within all articles, unread article links display a icon, partially read articles show a icon, and finished articles have a icon. This helps you track your learning progress.

Reading history is automatically synchronized across all devices.

3. Comprehensive Search Functionality

The search box in the upper right corner of the site supports a full-site search. You can directly search for explanations by entering a LeetCode problem, problem number, or link.

4. Supports All Major Programming Languages

All solution codes on this site and in all accompanying plugins support Java, C++, Python, Golang, JavaScript, and other common programming languages, catering to a broad range of readers' needs.

Java codes are written by me, while codes in other languages are translated with the help of chatGPT. However, each has been personally verified and debugged by me to ensure their accuracy and consistency.

5. Code Image Annotations

In this site and all accompanying plugins, complex code blocks include a lightbulb icon. Hovering over this icon will reveal an image to assist 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;
};

6. Supplementary Plugin for Practice

To cater to the diverse needs of readers, I have developed and maintained a supplementary plugin for the site, allowing readers to practice problems in their preferred code editor, conveniently during breaks.

The plugin integrates the Beginner's Directory and the Quick Mastery Directory. All problems discussed on this site have enhanced features, allowing you to view problem-solving strategies, visual panels, image annotations, and other practical functionalities.

The plugin is not mandatory, but I recommend installing the Chrome browser extension, as you might frequently switch to the LeetCode platform while reading this site. The Chrome extension can provide some assistance. You can choose to install the vscode/Jetbrain plugins based on your practice needs.

For installation and usage methods of each plugin, refer to Chrome Plugin, vscode Plugin, Jetbrain Plugin.