Learning Plan for Quick Mastery

Some readers have given me feedback: The content on this site is indeed solid. If studied seriously, one can thoroughly master data structures and algorithms. However, their current issue is a lack of time. What can be done?

Can we focus on the most essential skills first, learn them quickly, refine them in the short term, and delve deeper when more time is available later?

I believe this is a genuine need for a significant portion of readers, so I have specifically created this fast-track guide to meet their demands.

Naturally, a fast-track guide cannot cover everything comprehensively. Therefore, if you have ample time, I still recommend studying in the order of the Main Site Directory.

Before starting, spend two minutes to look at the first part of the Algorithm Visualization Panel User Guide to understand the basic usage of the visualization panel. All solution explanations are accompanied by visualizations, which can be used for debugging and verification if needed.

The quick learner's directory is mainly divided into a "Data Structures" section and an "Algorithm Problem Solving" section. The data structures section does not involve algorithmic problems and is relatively simple; the problem-solving section is the focus, and you must think carefully and practice hands-on.

Data Structures

Array and Linked List

This section introduces the basic concepts of arrays and linked lists, which are relatively simple. The key focus is on the circular array technique, which allows insertion and deletion operations at the head of the array with an $O(1)$ time complexity.

Principles and Applications of Hash Tables

As a quick tutorial, we can skip the code implementations of the two methods for resolving hash collisions in hash tables, but understanding the principles of hash tables is essential.

Hash tables can be combined with arrays and doubly linked lists to form more powerful data structures like LinkedHashMap and ArrayHashMap. These structures enhance hash tables with new features, and it's important to understand the underlying principles.

Basics of Binary Trees and Traversals

Although this is just a foundational knowledge section, the part about binary trees must be taken seriously, especially the traversal of binary trees, as it is key to understanding recursive thinking. When you start practicing problems later, you'll find that the essence of all recursive algorithms is binary tree traversal.

The structure of binary heaps is also included here, with priority queues being their key application. As this is a fast-track tutorial, we can skip the implementation of priority queues, but it is important to understand the following key points:

1. A priority queue is a data structure that can automatically sort elements, with insertion and deletion complexity of $O(\log N)$, implemented using a binary heap.

2. A binary heap is a complete binary tree with special properties.

3. The core methods of a priority queue (binary heap) are swim and sink, which are used to maintain the properties of the binary heap.

Graph Structures

Graph algorithms are a broad topic. However, as part of the foundational data structures section, we only need to understand the logical representation and concrete implementation of graphs, as well as graph traversal algorithms.

In essence, it's not too complex and is an extension of the binary tree structure discussed earlier.

Start Practicing Problems

Let's begin practicing problems by first understanding the basic rules of LeetCode.

• Guidelines for Solving LeetCode Problems
• Framework Thinking for Learning Data Structures and Algorithms

Linked Lists

Problems related to linked lists often follow fixed patterns, primarily utilizing the two-pointer technique.

An advanced technique for singly linked lists is using recursion, though this approach is typically only mentioned during interviews. For written tests, standard pointer operations should suffice.

Arrays

The main techniques related to arrays involve the two-pointer method, which can be categorized into slow-fast pointers and left-right pointers. Classic two-pointer algorithms for arrays include binary search and sliding windows.

Some readers have asked me why there isn't a dedicated section on string algorithms. This is because strings are essentially character arrays, and string algorithms are fundamentally array algorithms.

Queue/Stack

Queues and stacks are relatively simple data structures, but practicing their application in algorithm problems is essential.

Monotonic stacks and monotonic queues are two variations based on stacks and queues. They can solve specific problems and are important to master.

Binary Trees

The essence of all recursive algorithms lies in binary tree traversal. Binary tree algorithms frequently appear in interviews and exams. Therefore, I have included several articles in the binary tree section, and I hope everyone studies and understands them thoroughly and practices them hands-on.

Binary Search Tree

A Binary Search Tree (BST) is a special type of binary tree with the characteristic "left smaller, right larger." Make good use of this feature to optimize the traversal process of the binary tree.

Data Structure Design

LRU and LFU are classic data structure design problems that must be mastered.

The article about this calculator is a classic data structure design topic. If you don't have time to read it thoroughly, you can save the final calculator code. If you encounter string calculation-related questions in written exams, you can directly copy and paste it for use.

Graph Algorithms

Cycle detection, topological sorting, and bipartite graph determination are classic graph algorithms. Essentially, they involve traversing the graph and are not difficult to master.

The Union Find algorithm is a practical graph algorithm. You should have a basic understanding of its principles and API. If you don't have time to read thoroughly, you can save the UF class provided at the end for use during written tests.

Understanding the principles of Minimum Spanning Trees is necessary. You can learn about Kruskal's algorithm as it is relatively simple, essentially involving Union Find algorithm plus sorting.

Dijkstra's shortest path algorithm is a classic graph theory algorithm that you need to master. You can save the template for quick use during written tests.

DFS/Backtracking Algorithm

The backtracking algorithm is a purely brute-force enumeration method that must be mastered.

In exams, scores are based on the number of test cases passed. If you cannot derive the optimal solution for some problems, implementing a backtracking algorithm to perform brute-force enumeration might not pass all test cases, but it can pass some, earning you partial credit.

BFS

BFS, or Breadth-First Search, is a brute-force algorithm that is essential to learn. It traverses level by level and is well-suited for solving shortest path problems.

Dynamic Programming

Dynamic programming is essentially a brute-force method, but some problems have overlapping subproblems during the brute-force process, which can be optimized using a memoization technique. We typically refer to this type of algorithm as dynamic programming.

The brute-force solution in dynamic programming is generally in a recursive form. The optimization methods are quite fixed, either adding a memoization or converting the recursive approach into an iterative one.

The challenge in dynamic programming lies in formulating the brute-force solution or the state transition equation. Please read the following articles, paying special attention to the thought process of deriving the state transition equation.

Greedy Algorithm

In general algorithm problems, you need to exhaustively search all solutions to find the optimal one.

However, in some algorithm problems, if you fully utilize the information available, you can find the optimal solution without exhaustively searching all possibilities. This is known as the greedy choice property, and algorithms that use this property are called greedy algorithms.

Therefore, there is no fixed pattern for greedy algorithms. The key is to carefully observe and see if you can make full use of the information to eliminate some options that cannot possibly be the optimal solution.

Mathematics

In general, mathematical algorithms are not frequently tested in written exams, but it is essential to grasp some classic techniques.

Other Classic Interview Questions

Here are some classic algorithm problems, which are essentially applications of the algorithms introduced above. Once you have mastered the algorithms mentioned earlier, you should be able to tackle most common interview questions.