()
- // Initialize a max heap (Simply modify the Comparator using a lambda expression）
+ // Initialize a max heap (use lambda expression to modify Comparator)
val maxHeap = PriorityQueue { a: Int, b: Int -> b - a }
-
+
/* Push elements into the heap */
maxHeap.offer(1)
maxHeap.offer(3)
maxHeap.offer(2)
maxHeap.offer(5)
maxHeap.offer(4)
-
- /* Retrieve the top element of the heap */
+
+ /* Get the heap top element */
var peek = maxHeap.peek() // 5
-
- /* Pop the top element of the heap */
- // The popped elements will form a sequence in descending order
+
+ /* Remove the heap top element */
+ // The removed elements will form a descending sequence
peek = maxHeap.poll() // 5
peek = maxHeap.poll() // 4
peek = maxHeap.poll() // 3
peek = maxHeap.poll() // 2
peek = maxHeap.poll() // 1
-
- /* Get the size of the heap */
+
+ /* Get the heap size */
val size = maxHeap.size
-
+
/* Check if the heap is empty */
val isEmpty = maxHeap.isEmpty()
-
- /* Create a heap from a list */
+
+ /* Build a heap from an input list */
minHeap = PriorityQueue(mutableListOf(1, 3, 2, 5, 4))
```
=== "Ruby"
```ruby title="heap.rb"
-
+ # Ruby does not provide a built-in Heap class
```
=== "Zig"
@@ -414,33 +414,33 @@ Similar to sorting algorithms where we have "ascending order" and "descending or
```
-??? pythontutor "Code visualization"
+??? pythontutor "Code Visualization"
https://pythontutor.com/render.html#code=import%20heapq%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%B0%8F%E9%A1%B6%E5%A0%86%0A%20%20%20%20min_heap,%20flag%20%3D%20%5B%5D,%201%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20max_heap,%20flag%20%3D%20%5B%5D,%20-1%0A%20%20%20%20%0A%20%20%20%20%23%20Python%20%E7%9A%84%20heapq%20%E6%A8%A1%E5%9D%97%E9%BB%98%E8%AE%A4%E5%AE%9E%E7%8E%B0%E5%B0%8F%E9%A1%B6%E5%A0%86%0A%20%20%20%20%23%20%E8%80%83%E8%99%91%E5%B0%86%E2%80%9C%E5%85%83%E7%B4%A0%E5%8F%96%E8%B4%9F%E2%80%9D%E5%90%8E%E5%86%8D%E5%85%A5%E5%A0%86%EF%BC%8C%E8%BF%99%E6%A0%B7%E5%B0%B1%E5%8F%AF%E4%BB%A5%E5%B0%86%E5%A4%A7%E5%B0%8F%E5%85%B3%E7%B3%BB%E9%A2%A0%E5%80%92%EF%BC%8C%E4%BB%8E%E8%80%8C%E5%AE%9E%E7%8E%B0%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20%23%20%E5%9C%A8%E6%9C%AC%E7%A4%BA%E4%BE%8B%E4%B8%AD%EF%BC%8Cflag%20%3D%201%20%E6%97%B6%E5%AF%B9%E5%BA%94%E5%B0%8F%E9%A1%B6%E5%A0%86%EF%BC%8Cflag%20%3D%20-1%20%E6%97%B6%E5%AF%B9%E5%BA%94%E5%A4%A7%E9%A1%B6%E5%A0%86%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E5%A0%86%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%201%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%203%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%202%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%205%29%0A%20%20%20%20heapq.heappush%28max_heap,%20flag%20*%204%29%0A%20%20%20%20%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E5%A0%86%E9%A1%B6%E5%85%83%E7%B4%A0%0A%20%20%20%20peek%20%3D%20flag%20*%20max_heap%5B0%5D%20%23%205%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%A0%86%E9%A1%B6%E5%85%83%E7%B4%A0%E5%87%BA%E5%A0%86%0A%20%20%20%20%23%20%E5%87%BA%E5%A0%86%E5%85%83%E7%B4%A0%E4%BC%9A%E5%BD%A2%E6%88%90%E4%B8%80%E4%B8%AA%E4%BB%8E%E5%A4%A7%E5%88%B0%E5%B0%8F%E7%9A%84%E5%BA%8F%E5%88%97%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%205%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%204%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%203%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%202%0A%20%20%20%20val%20%3D%20flag%20*%20heapq.heappop%28max_heap%29%20%23%201%0A%20%20%20%20%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E5%A0%86%E5%A4%A7%E5%B0%8F%0A%20%20%20%20size%20%3D%20len%28max_heap%29%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E5%A0%86%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20not%20max_heap%0A%20%20%20%20%0A%20%20%20%20%23%20%E8%BE%93%E5%85%A5%E5%88%97%E8%A1%A8%E5%B9%B6%E5%BB%BA%E5%A0%86%0A%20%20%20%20min_heap%20%3D%20%5B1,%203,%202,%205,%204%5D%0A%20%20%20%20heapq.heapify%28min_heap%29&cumulative=false&curInstr=3&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false
## Implementation of the heap
-The following implementation is of a max heap. To convert it into a min heap, simply invert all size logic comparisons (for example, replace $\geq$ with $\leq$). Interested readers are encouraged to implement it on their own.
+The following implementation is of a max heap. To convert it to a min heap, simply invert all size logic comparisons (for example, replace $\geq$ with $\leq$). Interested readers are encouraged to implement this on their own.
### Heap storage and representation
-As mentioned in the "Binary Trees" section, complete binary trees are highly suitable for array representation. Since heaps are a type of complete binary tree, **we will use arrays to store heaps**.
+As mentioned in the "Binary Tree" chapter, complete binary trees are well-suited for array representation. Since heaps are a type of complete binary tree, **we will use arrays to store heaps**.
-When using an array to represent a binary tree, elements represent node values, and indexes represent node positions in the binary tree. **Node pointers are implemented through an index mapping formula**.
+When representing a binary tree with an array, elements represent node values, and indexes represent node positions in the binary tree. **Node pointers are implemented through index mapping formulas**.
-As shown in the figure below, given an index $i$, the index of its left child is $2i + 1$, the index of its right child is $2i + 2$, and the index of its parent is $(i - 1) / 2$ (floor division). When the index is out of bounds, it signifies a null node or the node does not exist.
+As shown in the figure below, given an index $i$, the index of its left child is $2i + 1$, the index of its right child is $2i + 2$, and the index of its parent is $(i - 1) / 2$ (floor division). When an index is out of bounds, it indicates a null node or that the node does not exist.
-We can encapsulate the index mapping formula into functions for convenient later use:
+We can encapsulate the index mapping formula into functions for convenient subsequent use:
```src
[file]{my_heap}-[class]{max_heap}-[func]{parent}
```
-### Accessing the top element of the heap
+### Accessing the heap top element
-The top element of the heap is the root node of the binary tree, which is also the first element of the list:
+The heap top element is the root node of the binary tree, which is also the first element of the list:
```src
[file]{my_heap}-[class]{max_heap}-[func]{peek}
@@ -448,12 +448,12 @@ The top element of the heap is the root node of the binary tree, which is also t
### Inserting an element into the heap
-Given an element `val`, we first add it to the bottom of the heap. After addition, since `val` may be larger than other elements in the heap, the heap's integrity might be compromised, **thus it's necessary to repair the path from the inserted node to the root node**. This operation is called heapify.
+Given an element `val`, we first add it to the bottom of the heap. After addition, since `val` may be larger than other elements in the heap, the heap's property may be violated. **Therefore, it's necessary to repair the path from the inserted node to the root node**. This operation is called heapify.
-Considering starting from the node inserted, **perform heapify from bottom to top**. As shown in the figure below, we compare the value of the inserted node with its parent node, and if the inserted node is larger, we swap them. Then continue this operation, repairing each node in the heap from bottom to top until reaching the root or a node that does not need swapping.
+Starting from the inserted node, **perform heapify from bottom to top**. As shown in the figure below, we compare the inserted node with its parent node, and if the inserted node is larger, swap them. Then continue this operation, repairing nodes in the heap from bottom to top until we pass the root node or encounter a node that does not need swapping.
=== "<1>"
- 
+ 
=== "<2>"
@@ -479,24 +479,24 @@ Considering starting from the node inserted, **perform heapify from bottom to to
=== "<9>"
-Given a total of $n$ nodes, the height of the tree is $O(\log n)$. Hence, the loop iterations for the heapify operation are at most $O(\log n)$, **making the time complexity of the element insertion operation $O(\log n)$**. The code is as shown:
+Given a total of $n$ nodes, the tree height is $O(\log n)$. Thus, the number of loop iterations in the heapify operation is at most $O(\log n)$, **making the time complexity of the element insertion operation $O(\log n)$**. The code is as follows:
```src
[file]{my_heap}-[class]{max_heap}-[func]{sift_up}
```
-### Removing the top element from the heap
+### Removing the heap top element
-The top element of the heap is the root node of the binary tree, that is, the first element of the list. If we directly remove the first element from the list, all node indexes in the binary tree will change, making it difficult to use heapify for subsequent repairs. To minimize changes in element indexes, we use the following steps.
+The heap top element is the root node of the binary tree, which is the first element of the list. If we directly remove the first element from the list, all node indexes in the binary tree would change, making subsequent repair with heapify difficult. To minimize changes in element indexes, we use the following steps.
-1. Swap the top element with the bottom element of the heap (swap the root node with the rightmost leaf node).
-2. After swapping, remove the bottom of the heap from the list (note that since it has been swapped, the original top element is actually being removed).
+1. Swap the heap top element with the heap bottom element (swap the root node with the rightmost leaf node).
+2. After swapping, remove the heap bottom from the list (note that since we've swapped, we're actually removing the original heap top element).
3. Starting from the root node, **perform heapify from top to bottom**.
-As shown in the figure below, **the direction of "heapify from top to bottom" is opposite to "heapify from bottom to top"**. We compare the value of the root node with its two children and swap it with the largest child. Then, repeat this operation until reaching the leaf node or encountering a node that does not need swapping.
+As shown in the figure below, **the direction of "top-to-bottom heapify" is opposite to "bottom-to-top heapify"**. We compare the root node's value with its two children and swap it with the largest child. Then loop this operation until we pass a leaf node or encounter a node that doesn't need swapping.
=== "<1>"
- 
+ 
=== "<2>"
@@ -525,7 +525,7 @@ As shown in the figure below, **the direction of "heapify from top to bottom" is
=== "<10>"
-Similar to the element insertion operation, the time complexity of the top element removal operation is also $O(\log n)$. The code is as follows:
+Similar to the element insertion operation, the time complexity of the heap top element removal operation is also $O(\log n)$. The code is as follows:
```src
[file]{my_heap}-[class]{max_heap}-[func]{sift_down}
@@ -533,6 +533,6 @@ Similar to the element insertion operation, the time complexity of the top eleme
## Common applications of heaps
-- **Priority Queue**: Heaps are often the preferred data structure for implementing priority queues, with both enqueue and dequeue operations having a time complexity of $O(\log n)$, and building a queue having a time complexity of $O(n)$, all of which are very efficient.
-- **Heap Sort**: Given a set of data, we can create a heap from them and then continually perform element removal operations to obtain ordered data. However, there is a more elegant way to implement heap sort, as explained in the "Heap Sort" chapter.
-- **Finding the Largest $k$ Elements**: This is a classic algorithm problem and also a common use case, such as selecting the top 10 hot news for Weibo hot search, picking the top 10 selling products, etc.
+- **Priority queue**: Heaps are typically the preferred data structure for implementing priority queues, with both enqueue and dequeue operations having a time complexity of $O(\log n)$, and the heap construction operation having $O(n)$, all of which are highly efficient.
+- **Heap sort**: Given a set of data, we can build a heap with them and then continuously perform element removal operations to obtain sorted data. However, we usually use a more elegant approach to implement heap sort, as detailed in the "Heap Sort" chapter.
+- **Getting the largest $k$ elements**: This is a classic algorithm problem and also a typical application, such as selecting the top 10 trending news for Weibo hot search, selecting the top 10 best-selling products, etc.
diff --git a/en/docs/chapter_heap/index.md b/en/docs/chapter_heap/index.md
index 30f2e3e10..405cfc4a1 100644
--- a/en/docs/chapter_heap/index.md
+++ b/en/docs/chapter_heap/index.md
@@ -4,6 +4,6 @@
!!! abstract
- Heaps resemble mountains and their jagged peaks, layered and undulating, each with its unique form.
+ Heaps are like mountain peaks, layered and undulating, each with its unique form.
- Each mountain peak rises and falls in scattered heights, yet the tallest always captures attention first.
+ The peaks rise and fall at varying heights, yet the tallest peak always catches the eye first.
diff --git a/en/docs/chapter_heap/summary.md b/en/docs/chapter_heap/summary.md
index 83b126f5f..6c65ea733 100644
--- a/en/docs/chapter_heap/summary.md
+++ b/en/docs/chapter_heap/summary.md
@@ -2,16 +2,16 @@
### Key review
-- A heap is a complete binary tree that can be categorized as either a max heap or a min heap based on its building property, where the top element of a max heap is the largest and the top element of a min heap is the smallest.
-- A priority queue is defined as a queue with dequeue priority, usually implemented using a heap.
-- Common operations of a heap and their corresponding time complexities include: element insertion into the heap $O(\log n)$, removing the top element from the heap $O(\log n)$, and accessing the top element of the heap $O(1)$.
-- A complete binary tree is well-suited to be represented by an array, thus heaps are commonly stored using arrays.
-- Heapify operations are used to maintain the properties of the heap and are used in both heap insertion and removal operations.
-- The time complexity of building a heap given an input of $n$ elements can be optimized to $O(n)$, which is highly efficient.
+- A heap is a complete binary tree that can be categorized as a max heap or min heap based on its property. The heap top element of a max heap (min heap) is the largest (smallest).
+- A priority queue is defined as a queue with priority sorting, typically implemented using heaps.
+- Common heap operations and their corresponding time complexities include: element insertion $O(\log n)$, heap top element removal $O(\log n)$, and accessing the heap top element $O(1)$.
+- Complete binary trees are well-suited for array representation, so we typically use arrays to store heaps.
+- Heapify operations are used to maintain the heap property and are employed in both element insertion and removal operations.
+- The time complexity of building a heap with $n$ input elements can be optimized to $O(n)$, which is highly efficient.
- Top-k is a classic algorithm problem that can be efficiently solved using the heap data structure, with a time complexity of $O(n \log k)$.
### Q & A
-**Q**: Is the "heap" in data structures the same concept as the "heap" in memory management?
+**Q**: Are the "heap" in data structures and the "heap" in memory management the same concept?
-The two are not the same concept, even though they are both referred to as "heap". The heap in computer system memory is part of dynamic memory allocation, where the program can use it to store data during execution. The program can request a certain amount of heap memory to store complex structures like objects and arrays. When the allocated data is no longer needed, the program needs to release this memory to prevent memory leaks. Compared to stack memory, the management and usage of heap memory demands more caution, as improper use may lead to memory leaks and dangling pointers.
+The two are not the same concept; they just happen to share the name "heap." The heap in computer system memory is part of dynamic memory allocation, where programs can use it to store data during runtime. Programs can request a certain amount of heap memory to store complex structures such as objects and arrays. When this data is no longer needed, the program needs to release this memory to prevent memory leaks. Compared to stack memory, heap memory management and usage require more caution, as improper use can lead to issues such as memory leaks and dangling pointers.
diff --git a/en/docs/chapter_heap/top_k.md b/en/docs/chapter_heap/top_k.md
index f267c0320..746241fd5 100644
--- a/en/docs/chapter_heap/top_k.md
+++ b/en/docs/chapter_heap/top_k.md
@@ -4,39 +4,39 @@
Given an unordered array `nums` of length $n$, return the largest $k$ elements in the array.
-For this problem, we will first introduce two straightforward solutions, then explain a more efficient heap-based method.
+For this problem, we'll first introduce two solutions with relatively straightforward approaches, then introduce a more efficient heap-based solution.
## Method 1: Iterative selection
-We can perform $k$ rounds of iterations as shown in the figure below, extracting the $1^{st}$, $2^{nd}$, $\dots$, $k^{th}$ largest elements in each round, with a time complexity of $O(nk)$.
+We can perform $k$ rounds of traversal as shown in the figure below, extracting the $1^{st}$, $2^{nd}$, $\dots$, $k^{th}$ largest elements in each round, with a time complexity of $O(nk)$.
-This method is only suitable when $k \ll n$, as the time complexity approaches $O(n^2)$ when $k$ is close to $n$, which is very time-consuming.
+This method is only suitable when $k \ll n$, because when $k$ is close to $n$, the time complexity approaches $O(n^2)$, which is very time-consuming.
-
+
!!! tip
- When $k = n$, we can obtain a complete ordered sequence, which is equivalent to the "selection sort" algorithm.
+ When $k = n$, we can obtain a complete sorted sequence, which is equivalent to the "selection sort" algorithm.
## Method 2: Sorting
-As shown in the figure below, we can first sort the array `nums` and then return the last $k$ elements, with a time complexity of $O(n \log n)$.
+As shown in the figure below, we can first sort the array `nums`, then return the rightmost $k$ elements, with a time complexity of $O(n \log n)$.
-Clearly, this method "overachieves" the task, as we only need to find the largest $k$ elements, without the need to sort the other elements.
+Clearly, this method "overachieves" the task, as we only need to find the largest $k$ elements, without needing to sort the other elements.
## Method 3: Heap
-We can solve the Top-k problem more efficiently based on heaps, as shown in the following process.
+We can solve the Top-k problem more efficiently using heaps, with the process shown in the figure below.
-1. Initialize a min heap, where the top element is the smallest.
-2. First, insert the first $k$ elements of the array into the heap.
-3. Starting from the $k + 1^{th}$ element, if the current element is greater than the top element of the heap, remove the top element of the heap and insert the current element into the heap.
-4. After completing the traversal, the heap contains the largest $k$ elements.
+1. Initialize a min heap, where the heap top element is the smallest.
+2. First, insert the first $k$ elements of the array into the heap in sequence.
+3. Starting from the $(k + 1)^{th}$ element, if the current element is greater than the heap top element, remove the heap top element and insert the current element into the heap.
+4. After traversal is complete, the heap contains the largest $k$ elements.
=== "<1>"
- 
+ 
=== "<2>"
@@ -68,6 +68,6 @@ Example code is as follows:
[file]{top_k}-[class]{}-[func]{top_k_heap}
```
-A total of $n$ rounds of heap insertions and deletions are performed, with the maximum heap size being $k$, hence the time complexity is $O(n \log k)$. This method is very efficient; when $k$ is small, the time complexity tends towards $O(n)$; when $k$ is large, the time complexity will not exceed $O(n \log n)$.
+A total of $n$ rounds of heap insertions and removals are performed, with the heap's maximum length being $k$, so the time complexity is $O(n \log k)$. This method is very efficient; when $k$ is small, the time complexity approaches $O(n)$; when $k$ is large, the time complexity does not exceed $O(n \log n)$.
-Additionally, this method is suitable for scenarios with dynamic data streams. By continuously adding data, we can maintain the elements within the heap, thereby achieving dynamic updates of the largest $k$ elements.
+Additionally, this method is suitable for dynamic data stream scenarios. By continuously adding data, we can maintain the elements in the heap, thus achieving dynamic updates of the largest $k$ elements.
diff --git a/en/docs/chapter_hello_algo/index.md b/en/docs/chapter_hello_algo/index.md
index 6953f39a5..7d398ed55 100644
--- a/en/docs/chapter_hello_algo/index.md
+++ b/en/docs/chapter_hello_algo/index.md
@@ -3,28 +3,28 @@ comments: true
icon: material/rocket-launch-outline
---
-# Before starting
+# Before Starting
-A few years ago, I shared the "Sword for Offer" problem solutions on LeetCode, receiving encouragement and support from many readers. During interactions with readers, the most common question I encountered was "how to get started with algorithms." Gradually, I developed a keen interest in this question.
+A few years ago, I shared the "Sword for Offer" problem solutions on LeetCode, receiving encouragement and support from many readers. During interactions with readers, the most frequently asked question I encountered was "how to get started with algorithms." Gradually, I developed a keen interest in this question.
-Directly solving problems seems to be the most popular method — it's simple, direct, and effective. However, problem-solving is like playing Minesweeper: those with strong self-study skills can navigate the pitfalls one by one, while those lacking a solid foundation may find themselves repeatedly stumbling and retreating in frustration. Reading through textbooks is also a common practice, but for job seekers, writing graduation thesis, submitting resumes, preparing for written tests and interviews have already consumed most of their energy, and reading thick books often becomes a daunting challenge.
+Diving straight into problem-solving seems to be the most popular approach—it's simple, direct, and effective. However, problem-solving is like playing Minesweeper: those with strong self-learning abilities can successfully defuse the mines one by one, while those with insufficient foundations may end up bruised and battered, retreating step by step in frustration. Reading through textbooks is also a common practice, but for job seekers, graduation theses, resume submissions, and preparations for written tests and interviews have already consumed most of their energy, making working through thick books an arduous challenge.
-If you're facing similar troubles, then this book is lucky to have found you. This book is my answer to the question. While it may not be the best solution, it is at least a positive attempt. Although this book is not enough to get you an offer directly, it will guide you to explore the "knowledge map" of data structures and algorithms, help you understand the shapes, sizes, and locations of different "mines", and enable you to master various "mine clearance methods". With these skills, I believe you can solve problems and read literature more comfortably, gradually building a knowledge system.
+If you're facing similar struggles, then it's fortunate that this book has "found" you. This book is my answer to this question—even if it may not be the optimal solution, it is at least a positive attempt. While this book alone won't directly land you a job offer, it will guide you to explore the "knowledge map" of data structures and algorithms, help you understand the shapes, sizes, and distributions of different "mines," and enable you to master various "mine-clearing methods." With these skills, I believe you can tackle problems and read technical literature more confidently, gradually building a complete knowledge system.
-I deeply agree with Professor Feynman's statement: "Knowledge isn't free. You have to pay attention." In this sense, this book is not entirely "free." In order to live up to your precious "attention" for this book, I will do my best and devote my greatest "attention" to write this book.
+I deeply agree with Professor Feynman's words: "Knowledge isn't free. You have to pay attention." In this sense, this book is not entirely "free." In order to live up to the precious "attention" you invest in this book, I will do my utmost and devote my greatest "attention" to completing this work.
-Aware of my limitations, I recognize that despite the content of this book being refined over time, errors surely remain. I sincerely welcome critiques and corrections from both teachers and students.
+I'm acutely aware of my limited knowledge and shallow expertise. Although the content of this book has been refined over a period of time, there are certainly still many errors, and I sincerely welcome critiques and corrections from teachers and fellow students.
-{ class="cover-image" }
+{ class="cover-image" }
-
Hello, Algo!
+ Hello, Algorithms!
-The advent of computers has brought significant changes to the world. With their high-speed computing power and excellent programmability, they have become the ideal medium for executing algorithms and processing data. Whether it's the realistic graphics of video games, the intelligent decisions in autonomous driving, the brilliant Go games of AlphaGo, or the natural interactions of ChatGPT, these applications are all exquisite demonstrations of algorithms at work on computers.
+The advent of computers has brought tremendous changes to the world. With their high-speed computing capabilities and excellent programmability, they have become the ideal medium for executing algorithms and processing data. Whether it's the realistic graphics in video games, the intelligent decision-making in autonomous driving, AlphaGo's brilliant Go matches, or ChatGPT's natural interactions, these applications are all exquisite interpretations of algorithms on computers.
-In fact, before the advent of computers, algorithms and data structures already existed in every corner of the world. Early algorithms were relatively simple, such as ancient counting methods and tool-making procedures. As civilization progressed, algorithms became more refined and complex. From the exquisite craftsmanship of artisans, to industrial products that liberate productive forces, to the scientific laws governing the universe, almost every ordinary or astonishing thing has behind it the ingenious thought of algorithms.
+In fact, before the advent of computers, algorithms and data structures already existed in every corner of the world. Early algorithms were relatively simple, such as ancient counting methods and tool-making procedures. As civilization progressed, algorithms gradually became more refined and complex. From the ingenious craftsmanship of master artisans, to industrial products that liberate productive forces, to the scientific laws governing the operation of the universe, behind almost every ordinary or astonishing thing lies ingenious algorithmic thinking.
-Similarly, data structures are everywhere: from social networks to subway lines, many systems can be modeled as "graphs"; from a country to a family, the main forms of social organization exhibit characteristics of "trees"; winter clothes are like a "stack", where the first item worn is the last to be taken off; a badminton shuttle tube resembles a "queue", with one end for insertion and the other for retrieval; a dictionary is like a "hash table", enabling quick search for target entries.
+Similarly, data structures are everywhere: from large-scale social networks to small subway systems, many systems can be modeled as "graphs"; from a nation to a family, the primary organizational forms of society exhibit characteristics of "trees"; winter clothing is like a "stack," where the first item put on is the last to be taken off; a badminton tube is like a "queue," with items inserted at one end and retrieved from the other; a dictionary is like a "hash table," enabling quick lookup of target entries.
-This book aims to help readers understand the core concepts of algorithms and data structures through clear, easy-to-understand animated illustrations and runnable code examples, and to be able to implement them through programming. On this basis, this book strives to reveal the vivid manifestations of algorithms in the complex world, showcasing the beauty of algorithms. I hope this book can help you!
+This book aims to help readers understand the core concepts of algorithms and data structures through clear and accessible animated illustrations and runnable code examples, and to implement them through programming. Building on this foundation, the book endeavors to reveal the vivid manifestations of algorithms in the complex world and showcase the beauty of algorithms. I hope this book can be of help to you!
diff --git a/en/docs/chapter_introduction/index.md b/en/docs/chapter_introduction/index.md
index 33c6c0daf..f6a58672a 100644
--- a/en/docs/chapter_introduction/index.md
+++ b/en/docs/chapter_introduction/index.md
@@ -1,9 +1,9 @@
-# Encounter with algorithms
+# Introduction to algorithms
-
+
!!! abstract
- A graceful maiden dances, intertwined with the data, her skirt swaying to the melody of algorithms.
-
- She invites you to a dance, follow her steps, and enter the world of algorithms full of logic and beauty.
+ A young girl dances gracefully, intertwined with data, her skirt flowing with the melody of algorithms.
+
+ She invites you to dance with her. Follow her steps closely and enter the world of algorithms, full of logic and beauty.
diff --git a/en/docs/chapter_introduction/summary.md b/en/docs/chapter_introduction/summary.md
index 0b40864cb..65160bfea 100644
--- a/en/docs/chapter_introduction/summary.md
+++ b/en/docs/chapter_introduction/summary.md
@@ -1,22 +1,22 @@
# Summary
-- Algorithms are ubiquitous in daily life and are not as inaccessible and complex as they might seem. In fact, we have already unconsciously learned many algorithms to solve various problems in life.
-- The principle of looking up a word in a dictionary is consistent with the binary search algorithm. The binary search algorithm embodies the important algorithmic concept of divide and conquer.
-- The process of organizing playing cards is very similar to the insertion sort algorithm. The insertion sort algorithm is suitable for sorting small datasets.
-- The steps of making change in currency essentially follow the greedy algorithm, where each step involves making the best possible choice at the moment.
-- An algorithm is a set of step-by-step instructions for solving a specific problem within a finite time, while a data structure defines how data is organized and stored in a computer.
-- Data structures and algorithms are closely linked. Data structures are the foundation of algorithms, and algorithms are the stage to utilize the functions of data structures.
-- We can compare data structures and algorithms to assembling building blocks. The blocks represent data, the shape and connection method of the blocks represent data structures, and the steps of assembling the blocks correspond to algorithms.
+- Algorithms are ubiquitous in daily life and are not distant, esoteric knowledge. In fact, we have already learned many algorithms unconsciously and use them to solve problems big and small in life.
+- The principle of looking up a dictionary is consistent with the binary search algorithm. Binary search embodies the important algorithmic idea of divide and conquer.
+- The process of organizing playing cards is very similar to the insertion sort algorithm. Insertion sort is suitable for sorting small datasets.
+- The steps of making change are essentially a greedy algorithm, where the best choice is made at each step based on the current situation.
+- An algorithm is a set of instructions or operational steps that solves a specific problem within a finite amount of time, while a data structure is the way computers organize and store data.
+- Data structures and algorithms are closely connected. Data structures are the foundation of algorithms, and algorithms breathe life into data structures.
+- We can compare data structures and algorithms to assembling building blocks. The blocks represent data, the shape and connection method of the blocks represent the data structure, and the steps to assemble the blocks correspond to the algorithm.
### Q & A
-**Q**：As a programmer, I’ve rarely needed to implement algorithms manually in my daily work. Most commonly used algorithms are already built into programming languages and libraries, ready to use. Does this suggest that the problems we encounter in our work haven’t yet reached the level of complexity that demands custom algorithm design?
+**Q**: As a programmer, I have never used algorithms to solve problems in my daily work. Common algorithms are already encapsulated by programming languages and can be used directly. Does this mean that the problems in our work have not yet reached the level where algorithms are needed?
-If specific work skills are like the "moves" in martial arts, then fundamental subjects are more like "internal strength".
+If we compare specific work skills to "techniques" in martial arts, then fundamental subjects should be more like "internal skills".
-I believe the significance of learning algorithms (and other fundamental subjects) isn’t necessarily to implement them from scratch at work, but to enable more professional decision-making and problem-solving based on a solid understanding of the concepts. This, in turn, raises the overall quality of our work. For example, every programming language provides a built-in sorting function:
+I believe the significance of learning algorithms (and other fundamental subjects) is not to implement them from scratch at work, but rather to be able to make professional reactions and judgments when solving problems based on the knowledge learned, thereby improving the overall quality of work. Here is a simple example. Every programming language has a built-in sorting function:
-- If we have not learned data structures and algorithms, then given any data, we might just give it to this sorting function. It runs smoothly, has good performance, and seems to have no problems.
-- However, if we’ve studied algorithms, we understand that the time complexity of a built-in sorting function is typically $O(n \log n)$. Moreover, if the data consists of integers with a fixed number of digits (such as student IDs), we can apply a more efficient approach like radix sort, reducing the time complexity to O(nk) , where k is the number of digits. When handling large volumes of data, the time saved can turn into significant value — lowering costs, improving user experience, and enhancing system performance.
+- If we have not studied data structures and algorithms, we might simply feed any given data to this sorting function. It runs smoothly with good performance, and there doesn't seem to be any problem.
+- But if we have studied algorithms, we would know that the time complexity of the built-in sorting function is $O(n \log n)$. However, if the given data consists of integers with a fixed number of digits (such as student IDs), we can use the more efficient "radix sort", reducing the time complexity to $O(nk)$, where $k$ is the number of digits. When the data volume is very large, the saved running time can create significant value (reduced costs, improved experience, etc.).
-In engineering, many problems are difficult to solve optimally; most are addressed with ‘near-optimal’ solutions. The difficulty of a problem depends not only on its inherent complexity but also on the knowledge and experience of the person tackling it. The deeper one’s expertise and experience, the more thorough the analysis, and the more elegantly the problem can be solved.
+In the field of engineering, a large number of problems are difficult to reach optimal solutions, and many problems are only solved "approximately". The difficulty of a problem depends on one hand on the nature of the problem itself, and on the other hand on the knowledge reserve of the person observing the problem. The more complete a person's knowledge and the more experience they have, the deeper their analysis of the problem will be, and the more elegantly the problem can be solved.
diff --git a/en/docs/chapter_introduction/what_is_dsa.md b/en/docs/chapter_introduction/what_is_dsa.md
index 264e93e13..7af5f3ad6 100644
--- a/en/docs/chapter_introduction/what_is_dsa.md
+++ b/en/docs/chapter_introduction/what_is_dsa.md
@@ -1,53 +1,53 @@
# What is an algorithm
-## Definition of an algorithm
+## Algorithm definition
-An algorithm is a set of instructions or steps to solve a specific problem within a finite amount of time. It has the following characteristics:
+An algorithm is a set of instructions or operational steps that solves a specific problem within a finite amount of time. It has the following characteristics.
-- The problem is clearly defined, including unambiguous definitions of input and output.
-- The algorithm is feasible, meaning it can be completed within a finite number of steps, time, and memory space.
-- Each step has a definitive meaning. The output is consistently the same under the same inputs and conditions.
+- The problem is well-defined, with clear input and output definitions.
+- It is feasible and can be completed within a finite number of steps, time, and memory space.
+- Each step has a definite meaning, and under the same input and operating conditions, the output is always the same.
-## Definition of a data structure
+## Data structure definition
-A data structure is a way of organizing and storing data in a computer, with the following design goals:
+A data structure is a way of organizing and storing data, covering the data content, relationships between data, and methods for data operations. It has the following design objectives.
-- Minimize space occupancy to save computer memory.
-- Make data operations as fast as possible, covering data access, addition, deletion, updating, etc.
-- Provide concise data representation and logical information to enable efficient algorithm execution.
+- Occupy as little space as possible to save computer memory.
+- Data operations should be as fast as possible, covering data access, addition, deletion, update, etc.
+- Provide a concise data representation and logical information so that algorithms can run efficiently.
-**Designing data structures is a balancing act, often requiring trade-offs**. If you want to improve in one aspect, you often need to compromise in another. Here are two examples:
+**Data structure design is a process full of trade-offs**. If we want to achieve improvements in one aspect, we often need to make compromises in another aspect. Here are two examples.
-- Compared to arrays, linked lists offer more convenience in data addition and deletion but sacrifice data access speed.
-- Compared with linked lists, graphs provide richer logical information but require more memory space.
+- Compared to arrays, linked lists are more convenient for data addition and deletion operations but sacrifice data access speed.
+- Compared to linked lists, graphs provide richer logical information but require larger memory space.
-## Relationship between data structures and algorithms
+## The relationship between data structures and algorithms
-As shown in the figure below, data structures and algorithms are highly related and closely integrated, specifically in the following three aspects:
+As shown in the figure below, data structures and algorithms are highly related and tightly coupled, specifically manifested in the following three aspects.
-- Data structures are the foundation of algorithms. They provide structured data storage and methods for manipulating data for algorithms.
-- Algorithms inject vitality into data structures. The data structure alone only stores data information; it is through the application of algorithms that specific problems can be solved.
-- Algorithms can often be implemented based on different data structures, but their execution efficiency can vary greatly. Choosing the right data structure is key.
+- Data structures are the foundation of algorithms. Data structures provide algorithms with structured storage of data and methods for operating on data.
+- Algorithms breathe life into data structures. Data structures themselves only store data information; combined with algorithms, they can solve specific problems.
+- Algorithms can usually be implemented based on different data structures, but execution efficiency may vary greatly. Choosing the appropriate data structure is key.
-
+
-Data structures and algorithms can be likened to a set of building blocks, as illustrated in the figure below. A building block set includes numerous pieces, accompanied by detailed assembly instructions. Following these instructions step by step allows us to construct an intricate block model.
+Data structures and algorithms are like assembling building blocks as shown in the figure below. A set of building blocks, in addition to containing many parts, also comes with detailed assembly instructions. By following the instructions step by step, we can assemble an exquisite building block model.
The detailed correspondence between the two is shown in the table below.
- Table Comparing data structures and algorithms to building blocks
+ Table Comparing data structures and algorithms to assembling building blocks
-| Data Structures and Algorithms | Building Blocks |
-| ------------------------------ | --------------------------------------------------------------- |
-| Input data | Unassembled blocks |
-| Data structure | Organization of blocks, including shape, size, connections, etc |
-| Algorithm | A series of steps to assemble the blocks into the desired shape |
-| Output data | Completed Block model |
+| Data structures and algorithms | Assembling building blocks |
+| ------------------------------ | ------------------------------------------------------------------ |
+| Input data | Unassembled building blocks |
+| Data structure | Organization form of building blocks, including shape, size, connection method, etc. |
+| Algorithm | A series of operational steps to assemble the blocks into the target form |
+| Output data | Building block model |
-It's worth noting that data structures and algorithms are independent of programming languages. For this reason, this book is able to provide implementations in multiple programming languages.
+It is worth noting that data structures and algorithms are independent of programming languages. For this reason, this book is able to provide implementations based on multiple programming languages.
-!!! tip "Conventional Abbreviation"
+!!! tip "Conventional abbreviation"
- In real-life discussions, we often refer to "Data Structures and Algorithms" simply as "Algorithms". For example, the well-known LeetCode algorithm questions actually test knowledge of both data structures and algorithms.
+ In actual discussions, we usually abbreviate "data structures and algorithms" as "algorithms". For example, the well-known LeetCode algorithm problems actually examine knowledge of both data structures and algorithms.
diff --git a/en/docs/chapter_preface/about_the_book.md b/en/docs/chapter_preface/about_the_book.md
index 010bfe34b..5e98f36fe 100644
--- a/en/docs/chapter_preface/about_the_book.md
+++ b/en/docs/chapter_preface/about_the_book.md
@@ -1,52 +1,52 @@
# About this book
-This open-source project aims to create a free, and beginner-friendly crash course on data structures and algorithms.
+This project aims to create an open-source, free, beginner-friendly introductory tutorial on data structures and algorithms.
-- Animated illustrations, easy-to-understand content, and a smooth learning curve help beginners explore the "knowledge map" of data structures and algorithms.
-- Run code with just one click, helping readers improve their programming skills and understand the working principle of algorithms and the underlying implementation of data structures.
-- Promoting learning by teaching, feel free to ask questions and share insights. Let's grow together through discussion.
+- The entire book uses animated illustrations, with clear and easy-to-understand content and a smooth learning curve, guiding beginners to explore the knowledge map of data structures and algorithms.
+- The source code can be run with one click, helping readers improve their programming skills through practice and understand how algorithms work and the underlying implementation of data structures.
+- We encourage readers to learn from each other, and everyone is welcome to ask questions and share insights in the comments section, making progress together through discussion and exchange.
## Target audience
-If you are new to algorithms with limited exposure, or you have accumulated some experience in algorithms, but you only have a vague understanding of data structures and algorithms, and you are constantly jumping between "yep" and "hmm", then this book is for you!
+If you are an algorithm beginner who has never been exposed to algorithms, or if you already have some problem-solving experience and have a vague understanding of data structures and algorithms, oscillating between knowing and not knowing, then this book is tailor-made for you!
-If you have already accumulated a certain amount of problem-solving experience, and are familiar with most types of problems, then this book can help you review and organize your algorithm knowledge system. The repository's source code can be used as a "problem-solving toolkit" or an "algorithm cheat sheet".
+If you have already accumulated a certain amount of problem-solving experience and are familiar with most question types, this book can help you review and organize your algorithm knowledge system, and the repository's source code can be used as a "problem-solving toolkit" or "algorithm dictionary."
-If you are an algorithm expert, we look forward to receiving your valuable suggestions, or [join us and collaborate](https://www.hello-algo.com/chapter_appendix/contribution/).
+If you are an algorithm "expert," we look forward to receiving your valuable suggestions, or [participating in creation together](https://www.hello-algo.com/chapter_appendix/contribution/).
!!! success "Prerequisites"
- You should know how to write and read simple code in at least one programming language.
+ You need to have at least a programming foundation in any language, and be able to read and write simple code.
## Content structure
-The main content of the book is shown in the figure below.
+The main content of this book is shown in the figure below.
-- **Complexity analysis**: explores aspects and methods for evaluating data structures and algorithms. Covers methods of deriving time complexity and space complexity, along with common types and examples.
-- **Data structures**: focuses on fundamental data types, classification methods, definitions, pros and cons, common operations, types, applications, and implementation methods of data structures such as array, linked list, stack, queue, hash table, tree, heap, graph, etc.
-- **Algorithms**: defines algorithms, discusses their pros and cons, efficiency, application scenarios, problem-solving steps, and includes sample questions for various algorithms such as search, sorting, divide and conquer, backtracking, dynamic programming, greedy algorithms, and more.
+- **Complexity analysis**: Evaluation dimensions and methods for data structures and algorithms. Methods for calculating time complexity and space complexity, common types, examples, etc.
+- **Data structures**: Classification methods for basic data types and data structures. The definition, advantages and disadvantages, common operations, common types, typical applications, implementation methods, etc. of data structures such as arrays, linked lists, stacks, queues, hash tables, trees, heaps, and graphs.
+- **Algorithms**: The definition, advantages and disadvantages, efficiency, application scenarios, problem-solving steps, and example problems of algorithms such as searching, sorting, divide and conquer, backtracking, dynamic programming, and greedy algorithms.
-
+
## Acknowledgements
-This book is continuously improved with the joint efforts of many contributors from the open-source community. Thanks to each writer who invested their time and energy, listed in the order generated by GitHub: krahets, coderonion, Gonglja, nuomi1, Reanon, justin-tse, hpstory, danielsss, curtishd, night-cruise, S-N-O-R-L-A-X, msk397, gvenusleo, khoaxuantu, RiverTwilight, rongyi, gyt95, zhuoqinyue, K3v123, Zuoxun, mingXta, hello-ikun, FangYuan33, GN-Yu, yuelinxin, longsizhuo, Cathay-Chen, guowei-gong, xBLACKICEx, IsChristina, JoseHung, qualifier1024, QiLOL, pengchzn, Guanngxu, L-Super, WSL0809, Slone123c, lhxsm, yuan0221, what-is-me, theNefelibatas, longranger2, cy-by-side, xiongsp, JeffersonHuang, Transmigration-zhou, magentaqin, Wonderdch, malone6, xiaomiusa87, gaofer, bluebean-cloud, a16su, Shyam-Chen, nanlei, hongyun-robot, Phoenix0415, MolDuM, Nigh, he-weilai, junminhong, mgisr, iron-irax, yd-j, XiaChuerwu, XC-Zero, seven1240, SamJin98, wodray, reeswell, NI-SW, Horbin-Magician, Enlightenus, xjr7670, YangXuanyi, DullSword, boloboloda, iStig, qq909244296, jiaxianhua, wenjianmin, keshida, kilikilikid, lclc6, lwbaptx, liuxjerry, lucaswangdev, lyl625760, hts0000, gledfish, fbigm, echo1937, szu17dmy, dshlstarr, Yucao-cy, coderlef, czruby, bongbongbakudan, beintentional, ZongYangL, ZhongYuuu, luluxia, xb534, bitsmi, ElaBosak233, baagod, zhouLion, yishangzhang, yi427, yabo083, weibk, wangwang105, th1nk3r-ing, tao363, 4yDX3906, syd168, steventimes, sslmj2020, smilelsb, siqyka, selear, sdshaoda, Xi-Row, popozhu, nuquist19, noobcodemaker, XiaoK29, chadyi, ZhongGuanbin, shanghai-Jerry, JackYang-hellobobo, Javesun99, lipusheng, BlindTerran, ShiMaRing, FreddieLi, FloranceYeh, iFleey, fanchenggang, gltianwen, goerll, Dr-XYZ, nedchu, curly210102, CuB3y0nd, KraHsu, CarrotDLaw, youshaoXG, bubble9um, fanenr, eagleanurag, LifeGoesOnionOnionOnion, 52coder, foursevenlove, KorsChen, hezhizhen, linzeyan, ZJKung, GaochaoZhu, hopkings2008, yang-le, Evilrabbit520, Turing-1024-Lee, thomasq0, Suremotoo, Allen-Scai, Risuntsy, Richard-Zhang1019, qingpeng9802, primexiao, nidhoggfgg, 1ch0, MwumLi, martinx, ZnYang2018, hugtyftg, logan-qiu, psychelzh, Keynman, KeiichiKasai and 0130w.
+This book has been continuously improved through the joint efforts of many contributors in the open-source community. Thanks to every writer who invested time and effort, they are (in the order automatically generated by GitHub): krahets, coderonion, Gonglja, nuomi1, Reanon, justin-tse, hpstory, danielsss, curtishd, night-cruise, S-N-O-R-L-A-X, msk397, gvenusleo, khoaxuantu, RiverTwilight, rongyi, gyt95, zhuoqinyue, K3v123, Zuoxun, mingXta, hello-ikun, FangYuan33, GN-Yu, yuelinxin, longsizhuo, Cathay-Chen, guowei-gong, xBLACKICEx, IsChristina, JoseHung, qualifier1024, QiLOL, pengchzn, Guanngxu, L-Super, WSL0809, Slone123c, lhxsm, yuan0221, what-is-me, theNefelibatas, longranger2, cy-by-side, xiongsp, JeffersonHuang, Transmigration-zhou, magentaqin, Wonderdch, malone6, xiaomiusa87, gaofer, bluebean-cloud, a16su, Shyam-Chen, nanlei, hongyun-robot, Phoenix0415, MolDuM, Nigh, he-weilai, junminhong, mgisr, iron-irax, yd-j, XiaChuerwu, XC-Zero, seven1240, SamJin98, wodray, reeswell, NI-SW, Horbin-Magician, Enlightenus, xjr7670, YangXuanyi, DullSword, boloboloda, iStig, qq909244296, jiaxianhua, wenjianmin, keshida, kilikilikid, lclc6, lwbaptx, liuxjerry, lucaswangdev, lyl625760, hts0000, gledfish, fbigm, echo1937, szu17dmy, dshlstarr, Yucao-cy, coderlef, czruby, bongbongbakudan, beintentional, ZongYangL, ZhongYuuu, luluxia, xb534, bitsmi, ElaBosak233, baagod, zhouLion, yishangzhang, yi427, yabo083, weibk, wangwang105, th1nk3r-ing, tao363, 4yDX3906, syd168, steventimes, sslmj2020, smilelsb, siqyka, selear, sdshaoda, Xi-Row, popozhu, nuquist19, noobcodemaker, XiaoK29, chadyi, ZhongGuanbin, shanghai-Jerry, JackYang-hellobobo, Javesun99, lipusheng, BlindTerran, ShiMaRing, FreddieLi, FloranceYeh, iFleey, fanchenggang, gltianwen, goerll, Dr-XYZ, nedchu, curly210102, CuB3y0nd, KraHsu, CarrotDLaw, youshaoXG, bubble9um, fanenr, eagleanurag, LifeGoesOnionOnionOnion, 52coder, foursevenlove, KorsChen, hezhizhen, linzeyan, ZJKung, GaochaoZhu, hopkings2008, yang-le, Evilrabbit520, Turing-1024-Lee, thomasq0, Suremotoo, Allen-Scai, Risuntsy, Richard-Zhang1019, qingpeng9802, primexiao, nidhoggfgg, 1ch0, MwumLi, martinx, ZnYang2018, hugtyftg, logan-qiu, psychelzh, Keynman, KeiichiKasai and 0130w.
-The code review work for this book was completed by coderonion, Gonglja, gvenusleo, hpstory, justin‐tse, khoaxuantu, krahets, night-cruise, nuomi1, Reanon and rongyi (listed in alphabetical order). Thanks to them for their time and effort, ensuring the standardization and uniformity of the code in various languages.
+The code review work for this book was completed by coderonion, curtishd, Gonglja, gvenusleo, hpstory, justin-tse, khoaxuantu, krahets, night-cruise, nuomi1, Reanon and rongyi (in alphabetical order). Thanks to them for the time and effort they put in, it is they who ensure the standardization and unity of code in various languages.
-The Traditional Chinese version of this book was reviewed by Shyam-Chen and Dr-XYZ, while the English version was reviewed by yuelinxin, K3v123, QiLOL, Phoenix0415, SamJin98, yanedie, RafaelCaso, pengchzn, thomasq0, and magentaqin. It is thanks to their continuous contributions that this book can reach and serve a broader audience.
+The Traditional Chinese version of this book was reviewed by Shyam-Chen and Dr-XYZ, and the English version was reviewed by yuelinxin, K3v123, QiLOL, Phoenix0415, SamJin98, yanedie, RafaelCaso, pengchzn, thomasq0 and magentaqin. It is because of their continuous contributions that this book can serve a wider readership, and we thank them.
-Throughout the creation of this book, numerous individuals provided invaluable assistance, including but not limited to:
+During the creation of this book, I received help from many people.
-- Thanks to my mentor at the company, Dr. Xi Li, who encouraged me in a conversation to "get moving fast," which solidified my determination to write this book;
-- Thanks to my girlfriend Bubble, as the first reader of this book, for offering many valuable suggestions from the perspective of a beginner in algorithms, making this book more suitable for newbies;
+- Thanks to my mentor at the company, Dr. Li Xi, who encouraged me to "take action quickly" during a conversation, strengthening my determination to write this book;
+- Thanks to my girlfriend Bubble as the first reader of this book, who provided many valuable suggestions from the perspective of an algorithm beginner, making this book more suitable for novices to read;
- Thanks to Tengbao, Qibao, and Feibao for coming up with a creative name for this book, evoking everyone's fond memories of writing their first line of code "Hello World!";
-- Thanks to Xiaoquan for providing professional help in intellectual property, which has played a significant role in the development of this open-source book;
-- Thanks to Sutong for designing a beautiful cover and logo for this book, and for patiently making multiple revisions under my insistence;
-- Thanks to @squidfunk for providing writing and typesetting suggestions, as well as his developed open-source documentation theme [Material-for-MkDocs](https://github.com/squidfunk/mkdocs-material/tree/master).
+- Thanks to Xiaoquan for providing professional help in intellectual property rights, which played an important role in the improvement of this open-source book;
+- Thanks to Sutong for designing the beautiful cover and logo for this book, and for patiently making revisions multiple times driven by my obsessive-compulsive disorder;
+- Thanks to @squidfunk for the typesetting suggestions, as well as for developing the open-source documentation theme [Material-for-MkDocs](https://github.com/squidfunk/mkdocs-material/tree/master).
-Throughout the writing journey, I delved into numerous textbooks and articles on data structures and algorithms. These works served as exemplary models, ensuring the accuracy and quality of this book's content. I extend my gratitude to all who preceded me for their invaluable contributions!
+During the writing process, I read many textbooks and articles on data structures and algorithms. These works provided excellent examples for this book and ensured the accuracy and quality of the book's content. I would like to thank all the teachers and predecessors for their outstanding contributions!
-This book advocates a combination of hands-on and minds-on learning, inspired in this regard by ["Dive into Deep Learning"](https://github.com/d2l-ai/d2l-en). I highly recommend this excellent book to all readers.
+This book advocates a learning method that combines hands and brain, and in this regard I was deeply inspired by [*Dive into Deep Learning*](https://github.com/d2l-ai/d2l-zh). I highly recommend this excellent work to all readers.
-**Heartfelt thanks to my parents, whose ongoing support and encouragement have allowed me to do this interesting work**.
+**Heartfelt thanks to my parents, it is your support and encouragement that has given me the opportunity to do this interesting thing**.
diff --git a/en/docs/chapter_preface/index.md b/en/docs/chapter_preface/index.md
index 332d997c7..971809b55 100644
--- a/en/docs/chapter_preface/index.md
+++ b/en/docs/chapter_preface/index.md
@@ -4,6 +4,6 @@
!!! abstract
- Algorithms are like a beautiful symphony, with each line of code flowing like a rhythm.
-
- May this book ring softly in your mind, leaving a unique and profound melody.
+ Algorithms are like a beautiful symphony, each line of code flows like a melody.
+
+ May this book gently resonate in your mind, leaving a unique and profound melody.
diff --git a/en/docs/chapter_preface/suggestions.md b/en/docs/chapter_preface/suggestions.md
index 393e50447..d15472c47 100644
--- a/en/docs/chapter_preface/suggestions.md
+++ b/en/docs/chapter_preface/suggestions.md
@@ -1,239 +1,252 @@
-# How to read
+# How to use this book
!!! tip
For the best reading experience, it is recommended that you read through this section.
-## Writing conventions
+## Writing style conventions
-- Chapters marked with '*' after the title are optional and contain relatively challenging content. If you are short on time, it is advisable to skip them.
-- Technical terms will be in boldface (in the print and PDF versions) or underlined (in the web version), for instance, array. It's advisable to familiarize yourself with these for better comprehension of technical texts.
-- **Bolded text** indicates key content or summary statements, which deserve special attention.
-- Words and phrases with specific meanings are indicated with “quotation marks” to avoid ambiguity.
-- When it comes to terms that are inconsistent between programming languages, this book follows Python, for example using `None` to mean `null`.
-- This book partially ignores the comment conventions for programming languages in exchange for a more compact layout of the content. The comments primarily consist of three types: title comments, content comments, and multi-line comments.
+- Titles marked with `*` are optional sections with relatively difficult content. If you have limited time, you can skip them first.
+- Technical terms will be in bold (in paper and PDF versions) or underlined (in web versions), such as array. It is recommended to memorize them for reading literature.
+- Key content and summary statements will be **bolded**, and such text deserves special attention.
+- Words and phrases with specific meanings will be marked with "quotation marks" to avoid ambiguity.
+- When it comes to nouns that are inconsistent between programming languages, this book uses Python as the standard, for example, using `None` to represent "null".
+- This book partially abandons the comment conventions of programming languages in favor of more compact content layout. Comments are mainly divided into three types: title comments, content comments, and multi-line comments.
=== "Python"
```python title=""
- """Header comments for labeling functions, classes, test samples, etc"""
-
- # Comments for explaining details
-
+ """Title comment, used to label functions, classes, test cases, etc."""
+
+ # Content comment, used to explain code in detail
+
"""
- Multiline
- comments
+ Multi-line
+ comment
"""
```
=== "C++"
```cpp title=""
- /* Header comments for labeling functions, classes, test samples, etc */
-
- // Comments for explaining details.
-
+ /* Title comment, used to label functions, classes, test cases, etc. */
+
+ // Content comment, used to explain code in detail
+
/**
- * Multiline
- * comments
+ * Multi-line
+ * comment
*/
```
=== "Java"
```java title=""
- /* Header comments for labeling functions, classes, test samples, etc */
-
- // Comments for explaining details.
-
+ /* Title comment, used to label functions, classes, test cases, etc. */
+
+ // Content comment, used to explain code in detail
+
/**
- * Multiline
- * comments
+ * Multi-line
+ * comment
*/
```
=== "C#"
```csharp title=""
- /* Header comments for labeling functions, classes, test samples, etc */
-
- // Comments for explaining details.
-
+ /* Title comment, used to label functions, classes, test cases, etc. */
+
+ // Content comment, used to explain code in detail
+
/**
- * Multiline
- * comments
+ * Multi-line
+ * comment
*/
```
=== "Go"
```go title=""
- /* Header comments for labeling functions, classes, test samples, etc */
-
- // Comments for explaining details.
-
+ /* Title comment, used to label functions, classes, test cases, etc. */
+
+ // Content comment, used to explain code in detail
+
/**
- * Multiline
- * comments
+ * Multi-line
+ * comment
*/
```
=== "Swift"
```swift title=""
- /* Header comments for labeling functions, classes, test samples, etc */
-
- // Comments for explaining details.
-
+ /* Title comment, used to label functions, classes, test cases, etc. */
+
+ // Content comment, used to explain code in detail
+
/**
- * Multiline
- * comments
+ * Multi-line
+ * comment
*/
```
=== "JS"
```javascript title=""
- /* Header comments for labeling functions, classes, test samples, etc */
-
- // Comments for explaining details.
-
+ /* Title comment, used to label functions, classes, test cases, etc. */
+
+ // Content comment, used to explain code in detail
+
/**
- * Multiline
- * comments
+ * Multi-line
+ * comment
*/
```
=== "TS"
```typescript title=""
- /* Header comments for labeling functions, classes, test samples, etc */
-
- // Comments for explaining details.
-
+ /* Title comment, used to label functions, classes, test cases, etc. */
+
+ // Content comment, used to explain code in detail
+
/**
- * Multiline
- * comments
+ * Multi-line
+ * comment
*/
```
=== "Dart"
```dart title=""
- /* Header comments for labeling functions, classes, test samples, etc */
-
- // Comments for explaining details.
-
+ /* Title comment, used to label functions, classes, test cases, etc. */
+
+ // Content comment, used to explain code in detail
+
/**
- * Multiline
- * comments
+ * Multi-line
+ * comment
*/
```
=== "Rust"
```rust title=""
- /* Header comments for labeling functions, classes, test samples, etc */
+ /* Title comment, used to label functions, classes, test cases, etc. */
+
+ // Content comment, used to explain code in detail
- // Comments for explaining details.
-
/**
- * Multiline
- * comments
+ * Multi-line
+ * comment
*/
```
=== "C"
```c title=""
- /* Header comments for labeling functions, classes, test samples, etc */
-
- // Comments for explaining details.
-
+ /* Title comment, used to label functions, classes, test cases, etc. */
+
+ // Content comment, used to explain code in detail
+
/**
- * Multiline
- * comments
+ * Multi-line
+ * comment
*/
```
=== "Kotlin"
```kotlin title=""
- /* Header comments for labeling functions, classes, test samples, etc */
-
- // Comments for explaining details.
-
+ /* Title comment, used to label functions, classes, test cases, etc. */
+
+ // Content comment, used to explain code in detail
+
/**
- * Multiline
- * comments
+ * Multi-line
+ * comment
*/
```
+=== "Ruby"
+
+ ```ruby title=""
+ ### Title comment, used to label functions, classes, test cases, etc. ###
+
+ # Content comment, used to explain code in detail
+
+ # Multi-line
+ # comment
+ ```
+
=== "Zig"
```zig title=""
- // Header comments for labeling functions, classes, test samples, etc
-
- // Comments for explaining details.
-
- // Multiline
- // comments
+ // Title comment, used to label functions, classes, test cases, etc.
+
+ // Content comment, used to explain code in detail
+
+ // Multi-line
+ // comment
```
-## Efficient learning via animated illustrations
+## Learning efficiently with animated illustrations
-Compared with text, videos and pictures have a higher density of information and are more structured, making them easier to understand. In this book, **key and difficult concepts are mainly presented through animations and illustrations**, with text serving as explanations and supplements.
+Compared to text, videos and images have higher information density and structural organization, making them easier to understand. In this book, **key and difficult knowledge will mainly be presented in the form of animated illustrations**, with text serving as explanation and supplement.
-When encountering content with animations or illustrations as shown in the figure below, **prioritize understanding the figure, with text as supplementary**, integrating both for a comprehensive understanding.
+If you find that a section of content provides animated illustrations as shown in the figure below while reading this book, **please focus on the illustrations first, with text as a supplement**, and combine the two to understand the content.
-
+
-## Deepen understanding through coding practice
+## Deepening understanding through code practice
-The source code of this book is hosted on the [GitHub Repository](https://github.com/krahets/hello-algo). As shown in the figure below, **the source code comes with test examples and can be executed with just a single click**.
+The accompanying code for this book is hosted in the [GitHub repository](https://github.com/krahets/hello-algo). As shown in the figure below, **the source code comes with test cases and can be run with one click**.
-If time permits, **it's recommended to type out the code yourself**. If pressed for time, at least read and run all the codes.
+If time permits, **it is recommended that you type out the code yourself**. If you have limited study time, please at least read through and run all the code.
-Compared to just reading code, writing code often yields more learning. **Learning by doing is the real way to learn.**
+Compared to reading code, the process of writing code often brings more rewards. **Learning by doing is the real learning**.
-
+
-Setting up to run the code involves three main steps.
+The preliminary work for running code is mainly divided into three steps.
-**Step 1: Install a local programming environment**. Follow the [tutorial](https://www.hello-algo.com/chapter_appendix/installation/) in the appendix for installation, or skip this step if already installed.
+**Step 1: Install the local programming environment**. Please follow the [tutorial](https://www.hello-algo.com/chapter_appendix/installation/) shown in the appendix for installation. If already installed, you can skip this step.
-**Step 2: Clone or download the code repository**. Visit the [GitHub Repository](https://github.com/krahets/hello-algo).
-
-If [Git](https://git-scm.com/downloads) is installed, use the following command to clone the repository:
+**Step 2: Clone or download the code repository**. Visit the [GitHub repository](https://github.com/krahets/hello-algo). If you have already installed [Git](https://git-scm.com/downloads), you can clone this repository with the following command:
```shell
git clone https://github.com/krahets/hello-algo.git
```
-Alternatively, you can also click the "Download ZIP" button at the location shown in the figure below to directly download the code as a compressed ZIP file. Then, you can simply extract it locally.
+Of course, you can also click the "Download ZIP" button at the location shown in the figure below to directly download the code compressed package, and then extract it locally.
-
+
-**Step 3: Run the source code**. As shown in the figure below, for the code block labeled with the file name at the top, we can find the corresponding source code file in the `codes` folder of the repository. These files can be executed with a single click, which will help you save unnecessary debugging time and allow you to focus on learning.
+**Step 3: Run the source code**. As shown in the figure below, for code blocks with file names at the top, we can find the corresponding source code files in the `codes` folder of the repository. The source code files can be run with one click, which will help you save unnecessary debugging time and allow you to focus on learning content.
-
+
-## Learning together in discussion
+In addition to running code locally, **the web version also supports visual running of Python code** (implemented based on [pythontutor](https://pythontutor.com/)). As shown in the figure below, you can click "Visual Run" below the code block to expand the view and observe the execution process of the algorithm code; you can also click "Full Screen View" for a better viewing experience.
-While reading this book, please don't skip over the points that you didn't learn. **Feel free to post your questions in the comment section**. We will be happy to answer them and can usually respond within two days.
+
-As illustrated in the figure below, each chapter features a comment section at the bottom. I encourage you to pay attention to these comments. They not only expose you to others' encountered problems, aiding in identifying knowledge gaps and sparking deeper contemplation, but also invite you to generously contribute by answering fellow readers' inquiries, sharing insights, and fostering mutual improvement.
+## Growing together through questions and discussions
-
+When reading this book, please do not easily skip knowledge points that you have not learned well. **Feel free to ask your questions in the comments section**, and my friends and I will do our best to answer you, and generally reply within two days.
-## Algorithm learning path
+As shown in the figure below, the web version has a comments section at the bottom of each chapter. I hope you will pay more attention to the content of the comments section. On the one hand, you can learn about the problems that everyone encounters, thus checking for omissions and stimulating deeper thinking. On the other hand, I hope you can generously answer other friends' questions, share your insights, and help others progress.
-Overall, the journey of mastering data structures and algorithms can be divided into three stages:
+
-1. **Stage 1: Introduction to algorithms**. We need to familiarize ourselves with the characteristics and usage of various data structures and learn about the principles, processes, uses, and efficiency of different algorithms.
-2. **Stage 2: Practicing algorithm problems**. It is recommended to start from popular problems, such as [Sword for Offer](https://leetcode.cn/studyplan/coding-interviews/) and [LeetCode Hot 100](https://leetcode.cn/studyplan/top-100- liked/), and accumulate at least 100 questions to familiarize yourself with mainstream algorithmic problems. Forgetfulness can be a challenge when you start practicing, but rest assured that this is normal. We can follow the "Ebbinghaus Forgetting Curve" to review the questions, and usually after 3~5 rounds of repetitions, we will be able to memorize them.
-3. **Stage 3: Building the knowledge system**. In terms of learning, we can read algorithm column articles, solution frameworks, and algorithm textbooks to continuously enrich the knowledge system. In terms of practicing, we can try advanced strategies, such as categorizing by topic, multiple solutions for a single problem, and one solution for multiple problems, etc. Insights on these strategies can be found in various communities.
+## Algorithm learning roadmap
-As shown in the figure below, this book mainly covers “Stage 1,” aiming to help you more efficiently embark on Stages 2 and 3.
+From an overall perspective, we can divide the process of learning data structures and algorithms into three stages.
-
+1. **Stage 1: Algorithm introduction**. We need to familiarize ourselves with the characteristics and usage of various data structures, and learn the principles, processes, uses, and efficiency of different algorithms.
+2. **Stage 2: Practice algorithm problems**. It is recommended to start with popular problems, and accumulate at least 100 problems first, to familiarize yourself with mainstream algorithm problems. When first practicing problems, "knowledge forgetting" may be a challenge, but rest assured, this is very normal. We can review problems according to the "Ebbinghaus forgetting curve", and usually after 3-5 rounds of repetition, we can firmly remember them. For recommended problem lists and practice plans, please see this [GitHub repository](https://github.com/krahets/LeetCode-Book).
+3. **Stage 3: Building a knowledge system**. In terms of learning, we can read algorithm column articles, problem-solving frameworks, and algorithm textbooks to continuously enrich our knowledge system. In terms of practicing problems, we can try advanced problem-solving strategies, such as categorization by topic, one problem multiple solutions, one solution multiple problems, etc. Related problem-solving insights can be found in various communities.
+
+As shown in the figure below, the content of this book mainly covers "Stage 1", aiming to help you more efficiently carry out Stage 2 and Stage 3 learning.
+
+
diff --git a/en/docs/chapter_preface/summary.md b/en/docs/chapter_preface/summary.md
index a1f02862a..1dc45a96d 100644
--- a/en/docs/chapter_preface/summary.md
+++ b/en/docs/chapter_preface/summary.md
@@ -1,8 +1,8 @@
# Summary
-- The main audience of this book is beginners in algorithm. If you already have some basic knowledge, this book can help you systematically review your algorithm knowledge, and the source code in this book can also be used as a "Coding Toolkit".
-- The book consists of three main sections, Complexity Analysis, Data Structures, and Algorithms, covering most of the topics in the field.
-- For newcomers to algorithms, it is crucial to read an introductory book in the beginning stages to avoid many detours or common pitfalls.
-- Animations and figures within the book are usually used to introduce key points and difficult knowledge. These should be given more attention when reading the book.
-- Practice is the best way to learn programming. It is highly recommended that you run the source code and type in the code yourself.
-- Each chapter in the web version of this book features a discussion section, and you are welcome to share your questions and insights at any time.
+- The main audience of this book is algorithm beginners. If you already have a certain foundation, this book can help you systematically review algorithm knowledge, and the source code in the book can also be used as a "problem-solving toolkit."
+- The content of the book mainly includes three parts: complexity analysis, data structures, and algorithms, covering most topics in this field.
+- For algorithm novices, reading an introductory book during the initial learning stage is crucial, as it can help you avoid many detours.
+- The animated illustrations in the book are usually used to introduce key and difficult knowledge. When reading this book, you should pay more attention to these contents.
+- Practice is the best way to learn programming. It is strongly recommended to run the source code and type the code yourself.
+- The web version of this book has a comments section for each chapter, where you are welcome to share your questions and insights at any time.
diff --git a/en/docs/chapter_reference/index.md b/en/docs/chapter_reference/index.md
index 39cf6a52c..2c015705f 100644
--- a/en/docs/chapter_reference/index.md
+++ b/en/docs/chapter_reference/index.md
@@ -16,7 +16,7 @@ icon: material/bookshelf
[6] Mark Allen Weiss, translated by Chen Yue. Data Structures and Algorithm Analysis in Java (Third Edition).
-[7] Cheng Jie. Speaking of Data Structures.
+[7] Cheng Jie. Conversational Data Structures.
[8] Wang Zheng. The Beauty of Data Structures and Algorithms.
diff --git a/en/docs/chapter_searching/binary_search.md b/en/docs/chapter_searching/binary_search.md
index 5384dd66f..e9d6eb61e 100644
--- a/en/docs/chapter_searching/binary_search.md
+++ b/en/docs/chapter_searching/binary_search.md
@@ -1,24 +1,24 @@
# Binary search
-Binary search is an efficient search algorithm that uses a divide-and-conquer strategy. It takes advantage of the sorted order of elements in an array by reducing the search interval by half in each iteration, continuing until either the target element is found or the search interval becomes empty.
+Binary search is an efficient searching algorithm based on the divide-and-conquer strategy. It leverages the orderliness of data to reduce the search range by half in each round until the target element is found or the search interval becomes empty.
!!! question
- Given an array `nums` of length $n$, where elements are arranged in ascending order without duplicates. Please find and return the index of element `target` in this array. If the array does not contain the element, return $-1$. An example is shown in the figure below.
+ Given an array `nums` of length $n$ with elements arranged in ascending order and no duplicates, search for and return the index of element `target` in the array. If the array does not contain the element, return $-1$. An example is shown in the figure below.
-As shown in the figure below, we firstly initialize pointers with $i = 0$ and $j = n - 1$, pointing to the first and last element of the array respectively. They also represent the whole search interval $[0, n - 1]$. Please note that square brackets indicate a closed interval, which includes the boundary values themselves.
+As shown in the figure below, we first initialize pointers $i = 0$ and $j = n - 1$, pointing to the first and last elements of the array respectively, representing the search interval $[0, n - 1]$. Note that square brackets denote a closed interval, which includes the boundary values themselves.
-And then the following two steps may be performed in a loop.
+Next, perform the following two steps in a loop:
1. Calculate the midpoint index $m = \lfloor {(i + j) / 2} \rfloor$, where $\lfloor \: \rfloor$ denotes the floor operation.
-2. Based on the comparison between the value of `nums[m]` and `target`, one of the following three cases will be chosen to execute.
- 1. If `nums[m] < target`, it indicates that `target` is in the interval $[m + 1, j]$, thus set $i = m + 1$.
- 2. If `nums[m] > target`, it indicates that `target` is in the interval $[i, m - 1]$, thus set $j = m - 1$.
- 3. If `nums[m] = target`, it indicates that `target` is found, thus return index $m$.
+2. Compare `nums[m]` and `target`, which results in three cases:
+ 1. When `nums[m] < target`, it indicates that `target` is in the interval $[m + 1, j]$, so execute $i = m + 1$.
+ 2. When `nums[m] > target`, it indicates that `target` is in the interval $[i, m - 1]$, so execute $j = m - 1$.
+ 3. When `nums[m] = target`, it indicates that `target` has been found, so return index $m$.
-If the array does not contain the target element, the search interval will eventually reduce to empty, ending up returning $-1$.
+If the array does not contain the target element, the search interval will eventually shrink to empty. In this case, return $-1$.
=== "<1>"
@@ -41,21 +41,21 @@ If the array does not contain the target element, the search interval will event
=== "<7>"
-It's worth noting that as $i$ and $j$ are both of type `int`, **$i + j$ might exceed the range of `int` type**. To avoid large number overflow, we usually use the formula $m = \lfloor {i + (j - i) / 2} \rfloor$ to calculate the midpoint.
+It's worth noting that since both $i$ and $j$ are of `int` type, **$i + j$ may exceed the range of the `int` type**. To avoid large number overflow, we typically use the formula $m = \lfloor {i + (j - i) / 2} \rfloor$ to calculate the midpoint.
-The code is as follows:
+The code is shown below:
```src
[file]{binary_search}-[class]{}-[func]{binary_search}
```
-**Time complexity is $O(\log n)$** : In the binary loop, the interval decreases by half each round, hence the number of iterations is $\log_2 n$.
+**Time complexity is $O(\log n)$**: In the binary loop, the interval is reduced by half each round, so the number of loops is $\log_2 n$.
-**Space complexity is $O(1)$** : Pointers $i$ and $j$ occupies constant size of space.
+**Space complexity is $O(1)$**: Pointers $i$ and $j$ use constant-size space.
## Interval representation methods
-Besides the above closed interval, another common interval representation is the "left-closed right-open" interval, defined as $[0, n)$, where the left boundary includes itself, and the right boundary does not. In this representation, the interval $[i, j)$ is empty when $i = j$.
+In addition to the closed interval mentioned above, another common interval representation is the "left-closed right-open" interval, defined as $[0, n)$, meaning the left boundary includes itself while the right boundary does not. Under this representation, the interval $[i, j)$ is empty when $i = j$.
We can implement a binary search algorithm with the same functionality based on this representation:
@@ -63,21 +63,21 @@ We can implement a binary search algorithm with the same functionality based on
[file]{binary_search}-[class]{}-[func]{binary_search_lcro}
```
-As shown in the figure below, under the two types of interval representations, the initialization, loop condition, and narrowing interval operation of the binary search algorithm differ.
+As shown in the figure below, under the two interval representations, the initialization, loop condition, and interval narrowing operations of the binary search algorithm are all different.
-Since both boundaries in the "closed interval" representation are inclusive, the operations to narrow the interval through pointers $i$ and $j$ are also symmetrical. This makes it less prone to errors, **therefore, it is generally recommended to use the "closed interval" approach**.
+Since both the left and right boundaries in the "closed interval" representation are defined as closed, the operations to narrow the interval through pointers $i$ and $j$ are also symmetric. This makes it less error-prone, **so the "closed interval" approach is generally recommended**.
-
+
## Advantages and limitations
Binary search performs well in both time and space aspects.
-- Binary search is time-efficient. With large dataset, the logarithmic time complexity offers a major advantage. For instance, given a dataset with size $n = 2^{20}$, linear search requires $2^{20} = 1048576$ iterations, while binary search only demands $\log_2 2^{20} = 20$ loops.
-- Binary search does not need extra space. Compared to search algorithms that rely on additional space (like hash search), binary search is more space-efficient.
+- Binary search has high time efficiency. With large data volumes, the logarithmic time complexity has significant advantages. For example, when the data size $n = 2^{20}$, linear search requires $2^{20} = 1048576$ loop rounds, while binary search only needs $\log_2 2^{20} = 20$ rounds.
+- Binary search requires no extra space. Compared to searching algorithms that require additional space (such as hash-based search), binary search is more space-efficient.
-However, binary search may not be suitable for all scenarios due to the following concerns.
+However, binary search is not suitable for all situations, mainly for the following reasons:
-- Binary search can only be applied to sorted data. Unsorted data must be sorted before applying binary search, which may not be worthwhile as sorting algorithm typically has a time complexity of $O(n \log n)$. Such cost is even higher than linear search, not to mention binary search itself. For scenarios with frequent insertion, the cost of remaining the array in order is pretty high as the time complexity of inserting new elements into specific positions is $O(n)$.
-- Binary search may use array only. Binary search requires non-continuous (jumping) element access, which is inefficient in linked list. As a result, linked list or data structures based on linked list may not be suitable for this algorithm.
-- Linear search performs better on small dataset. In linear search, only 1 decision operation is required for each iteration; whereas in binary search, it involves 1 addition, 1 division, 1 to 3 decision operations, 1 addition (subtraction), totaling 4 to 6 operations. Therefore, if data size $n$ is small, linear search is faster than binary search.
+- Binary search is only applicable to sorted data. If the input data is unsorted, sorting specifically to use binary search would be counterproductive, as sorting algorithms typically have a time complexity of $O(n \log n)$, which is higher than both linear search and binary search. For scenarios with frequent element insertions, maintaining array orderliness requires inserting elements at specific positions with a time complexity of $O(n)$, which is also very expensive.
+- Binary search is only applicable to arrays. Binary search requires jump-style (non-contiguous) element access, and jump-style access has low efficiency in linked lists, making it unsuitable for linked lists or data structures based on linked list implementations.
+- For small data volumes, linear search performs better. In linear search, each round requires only 1 comparison operation; while in binary search, it requires 1 addition, 1 division, 1-3 comparison operations, and 1 addition (subtraction), totaling 4-6 unit operations. Therefore, when the data volume $n$ is small, linear search is actually faster than binary search.
diff --git a/en/docs/chapter_searching/binary_search_edge.md b/en/docs/chapter_searching/binary_search_edge.md
index 844c2fb20..b2fe2a23c 100644
--- a/en/docs/chapter_searching/binary_search_edge.md
+++ b/en/docs/chapter_searching/binary_search_edge.md
@@ -1,56 +1,56 @@
-# Binary search boundaries
+# Binary search edge cases
-## Find the left boundary
+## Finding the left boundary
!!! question
- Given a sorted array `nums` of length $n$, which may contain duplicate elements, return the index of the leftmost element `target`. If the element is not present in the array, return $-1$.
+ Given a sorted array `nums` of length $n$ that may contain duplicate elements, return the index of the leftmost element `target` in the array. If the array does not contain the element, return $-1$.
-Recalling the method of binary search for an insertion point, after the search is completed, the index $i$ will point to the leftmost occurrence of `target`. Therefore, **searching for the insertion point is essentially the same as finding the index of the leftmost `target`**.
+Recall the method for finding the insertion point with binary search. After the search completes, $i$ points to the leftmost `target`, **so finding the insertion point is essentially finding the index of the leftmost `target`**.
-We can use the function for finding an insertion point to find the left boundary of `target`. Note that the array might not contain `target`, which could lead to the following two results:
+Consider implementing the left boundary search using the insertion point finding function. Note that the array may not contain `target`, which could result in the following two cases:
-- The index $i$ of the insertion point is out of bounds.
+- The insertion point index $i$ is out of bounds.
- The element `nums[i]` is not equal to `target`.
-In these cases, simply return $-1$. The code is as follows:
+When either of these situations occurs, simply return $-1$. The code is shown below:
```src
[file]{binary_search_edge}-[class]{}-[func]{binary_search_left_edge}
```
-## Find the right boundary
+## Finding the right boundary
-How do we find the rightmost occurrence of `target`? The most straightforward way is to modify the traditional binary search logic by changing how we adjust the search boundaries in the case of `nums[m] == target`. The code is omitted here. If you are interested, try to implement the code on your own.
+So how do we find the rightmost `target`? The most direct approach is to modify the code and replace the pointer shrinking operation in the `nums[m] == target` case. The code is omitted here; interested readers can implement it themselves.
-Below we are going to introduce two more ingenious methods.
+Below we introduce two more clever methods.
-### Reuse the left boundary search
+### Reusing left boundary search
-To find the rightmost occurrence of `target`, we can reuse the function used for locating the leftmost `target`. Specifically, we transform the search for the rightmost target into a search for the leftmost target + 1.
+In fact, we can use the function for finding the leftmost element to find the rightmost element. The specific method is: **Convert finding the rightmost `target` into finding the leftmost `target + 1`**.
-As shown in the figure below, after the search is complete, pointer $i$ will point to the leftmost `target + 1` (if exists), while pointer $j$ will point to the rightmost occurrence of `target`. Therefore, returning $j$ will give us the right boundary.
+As shown in the figure below, after the search completes, pointer $i$ points to the leftmost `target + 1` (if it exists), while $j$ points to the rightmost `target`, **so we can simply return $j$**.
-
+
-Note that the insertion point returned is $i$, therefore, it should be subtracted by $1$ to obtain $j$:
+Note that the returned insertion point is $i$, so we need to subtract $1$ from it to obtain $j$:
```src
[file]{binary_search_edge}-[class]{}-[func]{binary_search_right_edge}
```
-### Transform into an element search
+### Converting to element search
-When the array does not contain `target`, $i$ and $j$ will eventually point to the first element greater and smaller than `target` respectively.
+We know that when the array does not contain `target`, $i$ and $j$ will eventually point to the first elements greater than and less than `target`, respectively.
-Thus, as shown in the figure below, we can construct an element that does not exist in the array, to search for the left and right boundaries.
+Therefore, as shown in the figure below, we can construct an element that does not exist in the array to find the left and right boundaries.
-- To find the leftmost `target`: it can be transformed into searching for `target - 0.5`, and return the pointer $i$.
-- To find the rightmost `target`: it can be transformed into searching for `target + 0.5`, and return the pointer $j$.
+- Finding the leftmost `target`: Can be converted to finding `target - 0.5` and returning pointer $i$.
+- Finding the rightmost `target`: Can be converted to finding `target + 0.5` and returning pointer $j$.
-
+
-The code is omitted here, but here are two important points to note about this approach.
+The code is omitted here, but the following two points are worth noting:
-- The given array `nums` does not contain decimal, so handling equal cases is not a concern.
-- However, introducing decimals in this approach requires modifying the `target` variable to a floating-point type (no change needed in Python).
+- Since the given array does not contain decimals, we don't need to worry about how to handle equal cases.
+- Because this method introduces decimals, the variable `target` in the function needs to be changed to a floating-point type (Python does not require this change).
diff --git a/en/docs/chapter_searching/binary_search_insertion.md b/en/docs/chapter_searching/binary_search_insertion.md
index dd2c8a310..710c3c328 100644
--- a/en/docs/chapter_searching/binary_search_insertion.md
+++ b/en/docs/chapter_searching/binary_search_insertion.md
@@ -1,26 +1,26 @@
-# Binary search insertion
+# Binary search insertion point
-Binary search is not only used to search for target elements but also to solve many variant problems, such as searching for the insertion position of target elements.
+Binary search can not only be used to search for target elements but also to solve many variant problems, such as searching for the insertion position of a target element.
-## Case with no duplicate elements
+## Case without duplicate elements
!!! question
- Given a sorted array `nums` of length $n$ with unique elements and an element `target`, insert `target` into `nums` while maintaining its sorted order. If `target` already exists in the array, insert it to the left of the existing element. Return the index of `target` in the array after insertion. See the example shown in the figure below.
+ Given a sorted array `nums` of length $n$ and an element `target`, where the array contains no duplicate elements. Insert `target` into the array `nums` while maintaining its sorted order. If the array already contains the element `target`, insert it to its left. Return the index of `target` in the array after insertion. An example is shown in the figure below.
-
+
-If you want to reuse the binary search code from the previous section, you need to answer the following two questions.
+If we want to reuse the binary search code from the previous section, we need to answer the following two questions.
-**Question one**: If the array already contains `target`, would the insertion point be the index of existing element?
+**Question 1**: When the array contains `target`, is the insertion point index the same as that element's index?
-The requirement to insert `target` to the left of equal elements means that the newly inserted `target` will replace the original `target` position. In other words, **when the array contains `target`, the insertion point is indeed the index of that `target`**.
+The problem requires inserting `target` to the left of equal elements, which means the newly inserted `target` replaces the position of the original `target`. In other words, **when the array contains `target`, the insertion point index is the index of that `target`**.
-**Question two**: When the array does not contain `target`, at which index would it be inserted?
+**Question 2**: When the array does not contain `target`, what is the insertion point index?
-Let's further consider the binary search process: when `nums[m] < target`, pointer $i$ moves, meaning that pointer $i$ is approaching an element greater than or equal to `target`. Similarly, pointer $j$ is always approaching an element less than or equal to `target`.
+Further consider the binary search process: When `nums[m] < target`, $i$ moves, which means pointer $i$ is approaching elements greater than or equal to `target`. Similarly, pointer $j$ is always approaching elements less than or equal to `target`.
-Therefore, at the end of the binary, it is certain that: $i$ points to the first element greater than `target`, and $j$ points to the first element less than `target`. **It is easy to see that when the array does not contain `target`, the insertion point is $i$**. The code is as follows:
+Therefore, when the binary search ends, we must have: $i$ points to the first element greater than `target`, and $j$ points to the first element less than `target`. **It's easy to see that when the array does not contain `target`, the insertion index is $i$**. The code is shown below:
```src
[file]{binary_search_insertion}-[class]{}-[func]{binary_search_insertion_simple}
@@ -30,25 +30,25 @@ Therefore, at the end of the binary, it is certain that: $i$ points to the first
!!! question
- Based on the previous question, assume the array may contain duplicate elements, all else remains the same.
+ Based on the previous problem, assume the array may contain duplicate elements, with everything else remaining the same.
-When there are multiple occurrences of `target` in the array, a regular binary search can only return the index of one occurrence of `target`, **and it cannot determine how many occurrences of `target` are to the left and right of that position**.
+Suppose there are multiple `target` elements in the array. Ordinary binary search can only return the index of one `target`, **and cannot determine how many `target` elements are to the left and right of that element**.
-The problem requires inserting the target element at the leftmost position, **so we need to find the index of the leftmost `target` in the array**. Initially consider implementing this through the steps shown in the figure below.
+The problem requires inserting the target element at the leftmost position, **so we need to find the index of the leftmost `target` in the array**. Initially, consider implementing this through the steps shown in the figure below:
-1. Perform a binary search to find any index of `target`, say $k$.
-2. Starting from index $k$, conduct a linear search to the left until the leftmost occurrence of `target` is found, then return this index.
+1. Perform binary search to obtain the index of any `target`, denoted as $k$.
+2. Starting from index $k$, perform linear traversal to the left, and return when the leftmost `target` is found.
-
+
-Although this method is feasible, it includes linear search, so its time complexity is $O(n)$. This method is inefficient when the array contains many duplicate `target`s.
+Although this method works, it includes linear search, resulting in a time complexity of $O(n)$. When the array contains many duplicate `target` elements, this method is very inefficient.
-Now consider extending the binary search code. As shown in the figure below, the overall process remains the same. In each round, we first calculate the middle index $m$, then compare the value of `target` with `nums[m]`, leading to the following cases.
+Now consider extending the binary search code. As shown in the figure below, the overall process remains unchanged: calculate the midpoint index $m$ in each round, then compare `target` with `nums[m]`, divided into the following cases:
-- When `nums[m] < target` or `nums[m] > target`, it means `target` has not been found yet, thus use the normal binary search to narrow the search range, **bringing pointers $i$ and $j$ closer to `target`**.
-- When `nums[m] == target`, it indicates that the elements less than `target` are in the range $[i, m - 1]$, therefore use $j = m - 1$ to narrow the range, **thus bringing pointer $j$ closer to the elements less than `target`**.
+- When `nums[m] < target` or `nums[m] > target`, it means `target` has not been found yet, so use the ordinary binary search interval narrowing operation to **make pointers $i$ and $j$ approach `target`**.
+- When `nums[m] == target`, it means elements less than `target` are in the interval $[i, m - 1]$, so use $j = m - 1$ to narrow the interval, thereby **making pointer $j$ approach elements less than `target`**.
-After the loop, $i$ points to the leftmost `target`, and $j$ points to the first element less than `target`, **therefore index $i$ is the insertion point**.
+After the loop completes, $i$ points to the leftmost `target`, and $j$ points to the first element less than `target`, **so index $i$ is the insertion point**.
=== "<1>"
@@ -74,9 +74,9 @@ After the loop, $i$ points to the leftmost `target`, and $j$ points to the first
=== "<8>"
-Observe the following code. The operations in the branches `nums[m] > target` and `nums[m] == target` are the same, so these two branches can be merged.
+Observe the following code: the operations for branches `nums[m] > target` and `nums[m] == target` are the same, so the two can be merged.
-Even so, we can still keep the conditions expanded, as it makes the logic clearer and improves readability.
+Even so, we can still keep the conditional branches expanded, as the logic is clearer and more readable.
```src
[file]{binary_search_insertion}-[class]{}-[func]{binary_search_insertion}
@@ -84,8 +84,8 @@ Even so, we can still keep the conditions expanded, as it makes the logic cleare
!!! tip
- The code in this section uses "closed interval". If you are interested in "left-closed, right-open", try to implement the code on your own.
+ The code in this section all uses the "closed interval" approach. Interested readers can implement the "left-closed right-open" approach themselves.
-In summary, binary search essentially involves setting search targets for pointers $i$ and $j$. These targets could be a specific element (like `target`) or a range of elements (such as those smaller than `target`).
+Overall, binary search is simply about setting search targets for pointers $i$ and $j$ separately. The target could be a specific element (such as `target`) or a range of elements (such as elements less than `target`).
-In the continuous loop of binary search, pointers $i$ and $j$ gradually approach the predefined target. Ultimately, they either find the answer or stop after crossing the boundary.
+Through continuous binary iterations, both pointers $i$ and $j$ gradually approach their preset targets. Ultimately, they either successfully find the answer or stop after crossing the boundaries.
diff --git a/en/docs/chapter_searching/index.md b/en/docs/chapter_searching/index.md
index cf8ac7f2f..89abf6061 100644
--- a/en/docs/chapter_searching/index.md
+++ b/en/docs/chapter_searching/index.md
@@ -4,6 +4,6 @@
!!! abstract
- Searching is an adventure into the unknown; where we may need to traverse every corner of a mysterious space, or perhaps we’ll quickly locate our target.
-
- On this journey of discovery, each exploration may end up with an unexpected answer.
+ Searching is an adventure into the unknown, where we may need to traverse every corner of the mysterious space, or we may be able to quickly lock onto the target.
+
+ In this journey of discovery, each exploration may yield an unexpected answer.
diff --git a/en/docs/chapter_searching/replace_linear_by_hashing.md b/en/docs/chapter_searching/replace_linear_by_hashing.md
index c34ea97b9..7b0855ebb 100644
--- a/en/docs/chapter_searching/replace_linear_by_hashing.md
+++ b/en/docs/chapter_searching/replace_linear_by_hashing.md
@@ -1,16 +1,16 @@
-# Hash optimization strategies
+# Hash optimization strategy
-In algorithm problems, **we often reduce the time complexity of an algorithm by replacing a linear search with a hash-based search**. Let's use an algorithm problem to deepen the understanding.
+In algorithm problems, **we often reduce the time complexity of algorithms by replacing linear search with hash-based search**. Let's use an algorithm problem to deepen our understanding.
!!! question
- Given an integer array `nums` and a target element `target`, please search for two elements in the array whose "sum" equals `target`, and return their array indices. Any solution is acceptable.
+ Given an integer array `nums` and a target element `target`, search for two elements in the array whose "sum" equals `target`, and return their array indices. Any solution will do.
## Linear search: trading time for space
-Consider traversing through all possible combinations directly. As shown in the figure below, we initiate a nested loop, and in each iteration, we determine whether the sum of the two integers equals `target`. If so, we return their indices.
+Consider directly traversing all possible combinations. As shown in the figure below, we open a two-layer loop and judge in each round whether the sum of two integers equals `target`. If so, return their indices.
-
+
The code is shown below:
@@ -18,17 +18,17 @@ The code is shown below:
[file]{two_sum}-[class]{}-[func]{two_sum_brute_force}
```
-This method has a time complexity of $O(n^2)$ and a space complexity of $O(1)$, which can be very time-consuming with large data volumes.
+This method has a time complexity of $O(n^2)$ and a space complexity of $O(1)$, which is very time-consuming with large data volumes.
-## Hash search: trading space for time
+## Hash-based search: trading space for time
-Consider using a hash table, where the key-value pairs are the array elements and their indices, respectively. Loop through the array, performing the steps shown in the figure below during each iteration.
+Consider using a hash table where key-value pairs are array elements and element indices respectively. Loop through the array, performing the steps shown in the figure below in each round:
1. Check if the number `target - nums[i]` is in the hash table. If so, directly return the indices of these two elements.
2. Add the key-value pair `nums[i]` and index `i` to the hash table.
=== "<1>"
- 
+ 
=== "<2>"
@@ -42,6 +42,6 @@ The implementation code is shown below, requiring only a single loop:
[file]{two_sum}-[class]{}-[func]{two_sum_hash_table}
```
-This method reduces the time complexity from $O(n^2)$ to $O(n)$ by using hash search, significantly enhancing runtime efficiency.
+This method reduces the time complexity from $O(n^2)$ to $O(n)$ through hash-based search, greatly improving runtime efficiency.
-As it requires maintaining an additional hash table, the space complexity is $O(n)$. **Nevertheless, this method has a more balanced time-space efficiency overall, making it the optimal solution for this problem**.
+Since an additional hash table needs to be maintained, the space complexity is $O(n)$. **Nevertheless, this method achieves a more balanced overall time-space efficiency, making it the optimal solution for this problem**.
diff --git a/en/docs/chapter_searching/searching_algorithm_revisited.md b/en/docs/chapter_searching/searching_algorithm_revisited.md
index edee2ff28..4a24b8ab9 100644
--- a/en/docs/chapter_searching/searching_algorithm_revisited.md
+++ b/en/docs/chapter_searching/searching_algorithm_revisited.md
@@ -1,84 +1,84 @@
-# Search algorithms revisited
+# Searching algorithms revisited
-Searching algorithms (search algorithms) are used to retrieve one or more elements that meet specific criteria within data structures such as arrays, linked lists, trees, or graphs.
+Searching algorithms are used to search for one or a group of elements that meet specific conditions in data structures (such as arrays, linked lists, trees, or graphs).
-Searching algorithms can be divided into the following two categories based on their approach.
+Searching algorithms can be divided into the following two categories based on their implementation approach:
-- **Locating the target element by traversing the data structure**, such as traversals of arrays, linked lists, trees, and graphs, etc.
-- **Using the organizational structure of the data or existing data to achieve efficient element searches**, such as binary search, hash search, binary search tree search, etc.
+- **Locating target elements by traversing the data structure**, such as traversing arrays, linked lists, trees, and graphs.
+- **Achieving efficient element search by utilizing data organization structure or prior information contained in the data**, such as binary search, hash-based search, and binary search tree search.
-These topics were introduced in previous chapters, so they are not unfamiliar to us. In this section, we will revisit searching algorithms from a more systematic perspective.
+It's not hard to see that these topics have all been covered in previous chapters, so searching algorithms are not unfamiliar to us. In this section, we will approach from a more systematic perspective and re-examine searching algorithms.
## Brute-force search
-A Brute-force search locates the target element by traversing every element of the data structure.
+Brute-force search locates target elements by traversing each element of the data structure.
-- "Linear search" is suitable for linear data structures such as arrays and linked lists. It starts from one end of the data structure and accesses each element one by one until the target element is found or the other end is reached without finding the target element.
-- "Breadth-first search" and "Depth-first search" are two traversal strategies for graphs and trees. Breadth-first search starts from the initial node and searches layer by layer (left to right), accessing nodes from near to far. Depth-first search starts from the initial node, follows a path until the end (top to bottom), then backtracks and tries other paths until the entire data structure is traversed.
+- "Linear search" is applicable to linear data structures such as arrays and linked lists. It starts from one end of the data structure and accesses elements one by one until the target element is found or the other end is reached without finding the target element.
+- "Breadth-first search" and "depth-first search" are two traversal strategies for graphs and trees. Breadth-first search starts from the initial node and searches layer by layer, visiting nodes from near to far. Depth-first search starts from the initial node, follows a path to the end, then backtracks and tries other paths until the entire data structure is traversed.
-The advantage of brute-force search is its simplicity and versatility, **no need for data preprocessing or the help of additional data structures**.
+The advantage of brute-force search is that it is simple and has good generality, **requiring no data preprocessing or additional data structures**.
-However, **the time complexity of this type of algorithm is $O(n)$**, where $n$ is the number of elements, so the performance is poor with large data sets.
+However, **the time complexity of such algorithms is $O(n)$**, where $n$ is the number of elements, so performance is poor when dealing with large amounts of data.
## Adaptive search
-An Adaptive search uses the unique properties of data (such as order) to optimize the search process, thereby locating the target element more efficiently.
+Adaptive search utilizes the unique properties of data (such as orderliness) to optimize the search process, thereby locating target elements more efficiently.
-- "Binary search" uses the orderliness of data to achieve efficient searching, only suitable for arrays.
-- "Hash search" uses a hash table to establish a key-value mapping between search data and target data, thus implementing the query operation.
-- "Tree search" in a specific tree structure (such as a binary search tree), quickly eliminates nodes based on node value comparisons, thus locating the target element.
+- "Binary search" uses the orderliness of data to achieve efficient searching, applicable only to arrays.
+- "Hash-based search" uses hash tables to establish key-value pair mappings between search data and target data, thereby achieving query operations.
+- "Tree search" in specific tree structures (such as binary search trees), quickly eliminates nodes based on comparing node values to locate target elements.
-The advantage of these algorithms is high efficiency, **with time complexities reaching $O(\log n)$ or even $O(1)$**.
+The advantage of such algorithms is high efficiency, **with time complexity reaching $O(\log n)$ or even $O(1)$**.
-However, **using these algorithms often requires data preprocessing**. For example, binary search requires sorting the array in advance, and hash search and tree search both require the help of additional data structures. Maintaining these structures also requires more overhead in terms of time and space.
+However, **using these algorithms often requires data preprocessing**. For example, binary search requires pre-sorting the array, while hash-based search and tree search both require additional data structures, and maintaining these data structures also requires extra time and space overhead.
!!! tip
- Adaptive search algorithms are often referred to as search algorithms, **mainly used for quickly retrieving target elements in specific data structures**.
+ Adaptive search algorithms are often called lookup algorithms, **mainly used to quickly retrieve target elements in specific data structures**.
-## Choosing a search method
+## Search method selection
-Given a set of data of size $n$, we can use a linear search, binary search, tree search, hash search, or other methods to retrieve the target element. The working principles of these methods are shown in the figure below.
+Given a dataset of size $n$, we can use linear search, binary search, tree search, hash-based search, and other methods to search for the target element. The working principles of each method are shown in the figure below.
-
+
-The characteristics and operational efficiency of the aforementioned methods are shown in the following table.
+The operational efficiency and characteristics of the above methods are as follows:
Table Comparison of search algorithm efficiency
-| | Linear search | Binary search | Tree search | Hash search |
+| | Linear search | Binary search | Tree search | Hash-based search |
| ------------------ | ------------- | --------------------- | --------------------------- | -------------------------- |
| Search element | $O(n)$ | $O(\log n)$ | $O(\log n)$ | $O(1)$ |
| Insert element | $O(1)$ | $O(n)$ | $O(\log n)$ | $O(1)$ |
| Delete element | $O(n)$ | $O(n)$ | $O(\log n)$ | $O(1)$ |
| Extra space | $O(1)$ | $O(1)$ | $O(n)$ | $O(n)$ |
-| Data preprocessing | / | Sorting $O(n \log n)$ | Building tree $O(n \log n)$ | Building hash table $O(n)$ |
-| Data orderliness | Unordered | Ordered | Ordered | Unordered |
+| Data preprocessing | / | Sorting $O(n \log n)$ | Tree building $O(n \log n)$ | Hash table building $O(n)$ |
+| Data ordered | Unordered | Ordered | Ordered | Unordered |
-The choice of search algorithm also depends on the volume of data, search performance requirements, frequency of data queries and updates, etc.
+The choice of search algorithm also depends on data volume, search performance requirements, data query and update frequency, etc.
**Linear search**
-- Good versatility, no need for any data preprocessing operations. If we only need to query the data once, then the time for data preprocessing in the other three methods would be longer than the time for a linear search.
-- Suitable for small volumes of data, where time complexity has a smaller impact on efficiency.
-- Suitable for scenarios with very frequent data updates, because this method does not require any additional maintenance of the data.
+- Good generality, requiring no data preprocessing operations. If we only need to query the data once, the data preprocessing time for the other three methods would be longer than linear search.
+- Suitable for small data volumes, where time complexity has less impact on efficiency.
+- Suitable for scenarios with high data update frequency, as this method does not require any additional data maintenance.
**Binary search**
-- Suitable for larger data volumes, with stable performance and a worst-case time complexity of $O(\log n)$.
-- However, the data volume cannot be too large, because storing arrays requires contiguous memory space.
-- Not suitable for scenarios with frequent additions and deletions, because maintaining an ordered array incurs a lot of overhead.
+- Suitable for large data volumes with stable efficiency performance, worst-case time complexity of $O(\log n)$.
+- Data volume cannot be too large, as storing arrays requires contiguous memory space.
+- Not suitable for scenarios with frequent data insertion and deletion, as maintaining a sorted array has high overhead.
-**Hash search**
+**Hash-based search**
-- Suitable for scenarios where fast query performance is essential, with an average time complexity of $O(1)$.
-- Not suitable for scenarios needing ordered data or range searches, because hash tables cannot maintain data orderliness.
-- High dependency on hash functions and hash collision handling strategies, with significant performance degradation risks.
-- Not suitable for overly large data volumes, because hash tables need extra space to minimize collisions and provide good query performance.
+- Suitable for scenarios with high query performance requirements, with an average time complexity of $O(1)$.
+- Not suitable for scenarios requiring ordered data or range searches, as hash tables cannot maintain data orderliness.
+- High dependence on hash functions and hash collision handling strategies, with significant risk of performance degradation.
+- Not suitable for excessively large data volumes, as hash tables require extra space to minimize collisions and thus provide good query performance.
**Tree search**
-- Suitable for massive data, because tree nodes are stored scattered in memory.
-- Suitable for maintaining ordered data or range searches.
-- With the continuous addition and deletion of nodes, the binary search tree may become skewed, degrading the time complexity to $O(n)$.
-- If using AVL trees or red-black trees, operations can run stably at $O(\log n)$ efficiency, but the operation to maintain tree balance adds extra overhead.
+- Suitable for massive data, as tree nodes are stored dispersedly in memory.
+- Suitable for scenarios requiring maintained ordered data or range searches.
+- During continuous node insertion and deletion, binary search trees may become skewed, degrading time complexity to $O(n)$.
+- If using AVL trees or red-black trees, all operations can run stably at $O(\log n)$ efficiency, but operations to maintain tree balance add extra overhead.
diff --git a/en/docs/chapter_searching/summary.md b/en/docs/chapter_searching/summary.md
index d6169a17a..aa834a598 100644
--- a/en/docs/chapter_searching/summary.md
+++ b/en/docs/chapter_searching/summary.md
@@ -1,8 +1,8 @@
# Summary
-- Binary search depends on the order of data and performs the search by iteratively halving the search interval. It requires the input data to be sorted and is only applicable to arrays or array-based data structures.
-- Brute force search may be required to locate an entry in an unordered dataset. Different search algorithms can be applied based on the data structure: Linear search is suitable for arrays and linked lists, while breadth-first search (BFS) and depth-first search (DFS) are suitable for graphs and trees. These algorithms are highly versatile, requiring no preprocessing of data, but they have a higher time complexity of $O(n)$.
-- Hash search, tree search, and binary search are efficient search methods that can quickly locate target elements within specific data structures. These algorithms are highly efficient, with time complexities reaching $O(\log n)$ or even $O(1)$, but they usually require extra space to accommodate additional data structures.
-- In practice, we need to analyze factors such as data volume, search performance requirements, data query and update frequencies, etc., to choose an appropriate search method.
-- Linear search is ideal for small or frequently updated (volatile) data. Binary search works well for large and sorted data. Hash search is suitable for data that requires high query efficiency and does not need range queries. Tree search is best suited for large dynamic data that require maintaining order and need to support range queries.
-- Replacing linear search with hash search is a common strategy to optimize runtime performance, reducing the time complexity from $O(n)$ to $O(1)$.
+- Binary search relies on data orderliness and progressively reduces the search interval by half through loops. It requires input data to be sorted and is only applicable to arrays or data structures based on array implementations.
+- Brute-force search locates data by traversing the data structure. Linear search is applicable to arrays and linked lists, while breadth-first search and depth-first search are applicable to graphs and trees. Such algorithms have good generality and require no data preprocessing, but have a relatively high time complexity of $O(n)$.
+- Hash-based search, tree search, and binary search are efficient search methods that can quickly locate target elements in specific data structures. Such algorithms are highly efficient with time complexity reaching $O(\log n)$ or even $O(1)$, but typically require additional data structures.
+- In practice, we need to analyze factors such as data scale, search performance requirements, and data query and update frequency to choose the appropriate search method.
+- Linear search is suitable for small-scale or frequently updated data; binary search is suitable for large-scale, sorted data; hash-based search is suitable for data with high query efficiency requirements and no need for range queries; tree search is suitable for large-scale dynamic data that needs to maintain order and support range queries.
+- Replacing linear search with hash-based search is a commonly used strategy to optimize runtime, reducing time complexity from $O(n)$ to $O(1)$.
diff --git a/en/docs/chapter_sorting/bubble_sort.md b/en/docs/chapter_sorting/bubble_sort.md
index 577ec2eff..9873539c1 100644
--- a/en/docs/chapter_sorting/bubble_sort.md
+++ b/en/docs/chapter_sorting/bubble_sort.md
@@ -1,11 +1,11 @@
# Bubble sort
-Bubble sort works by continuously comparing and swapping adjacent elements. This process is like bubbles rising from the bottom to the top, hence the name "bubble sort."
+Bubble sort (bubble sort) achieves sorting by continuously comparing and swapping adjacent elements. This process is like bubbles rising from the bottom to the top, hence the name bubble sort.
-As shown in the figure below, the bubbling process can be simulated using element swaps: start from the leftmost end of the array and move right, comparing each pair of adjacent elements. If the left element is greater than the right element, swap them. After the traversal, the largest element will have bubbled up to the rightmost end of the array.
+As shown in the figure below, the bubbling process can be simulated using element swap operations: starting from the leftmost end of the array and traversing to the right, compare the size of adjacent elements, and if "left element > right element", swap them. After completing the traversal, the largest element will be moved to the rightmost end of the array.
=== "<1>"
- 
+ 
=== "<2>"
@@ -25,16 +25,16 @@ As shown in the figure below, the bubbling process can be simulated using elemen
=== "<7>"
-## Algorithm process
+## Algorithm flow
-Assume the array has length $n$. The steps of bubble sort are shown in the figure below:
+Assume the array has length $n$. The steps of bubble sort are shown in the figure below.
-1. First, perform one "bubble" pass on $n$ elements, **swapping the largest element to its correct position**.
-2. Next, perform a "bubble" pass on the remaining $n - 1$ elements, **swapping the second largest element to its correct position**.
-3. Continue in this manner; after $n - 1$ such passes, **the largest $n - 1$ elements will have been moved to their correct positions**.
-4. The only remaining element **must** be the smallest, so **no** further sorting is required. At this point, the array is sorted.
+1. First, perform "bubbling" on $n$ elements, **swapping the largest element of the array to its correct position**.
+2. Next, perform "bubbling" on the remaining $n - 1$ elements, **swapping the second largest element to its correct position**.
+3. And so on. After $n - 1$ rounds of "bubbling", **the largest $n - 1$ elements have all been swapped to their correct positions**.
+4. The only remaining element must be the smallest element, requiring no sorting, so the array sorting is complete.
-
+
Example code is as follows:
@@ -44,9 +44,9 @@ Example code is as follows:
## Efficiency optimization
-If no swaps occur during a round of "bubbling," the array is already sorted, so we can return immediately. To detect this, we can add a `flag` variable; whenever no swaps are made in a pass, we set the flag and return early.
+We notice that if no swap operations are performed during a certain round of "bubbling", it means the array has already completed sorting and can directly return the result. Therefore, we can add a flag `flag` to monitor this situation and return immediately once it occurs.
-Even with this optimization, the worst time complexity and average time complexity of bubble sort remains $O(n^2)$. However, if the input array is already sorted, the best-case time complexity can be as low as $O(n)$.
+After optimization, the worst-case time complexity and average time complexity of bubble sort remain $O(n^2)$; but when the input array is completely ordered, the best-case time complexity can reach $O(n)$.
```src
[file]{bubble_sort}-[class]{}-[func]{bubble_sort_with_flag}
@@ -54,6 +54,6 @@ Even with this optimization, the worst time complexity and average time complexi
## Algorithm characteristics
-- **Time complexity of $O(n^2)$, adaptive sorting.** Each round of "bubbling" traverses array segments of length $n - 1$, $n - 2$, $\dots$, $2$, $1$, which sums to $(n - 1) n / 2$. With a `flag` optimization, the best-case time complexity can reach $O(n)$ when the array is already sorted.
-- **Space complexity of $O(1)$, in-place sorting.** Only a constant amount of extra space is used by pointers $i$ and $j$.
-- **Stable sorting.** Because equal elements are not swapped during "bubbling," their original order is preserved, making this a stable sort.
+- **Time complexity of $O(n^2)$, adaptive sorting**: The array lengths traversed in each round of "bubbling" are $n - 1$, $n - 2$, $\dots$, $2$, $1$, totaling $(n - 1) n / 2$. After introducing the `flag` optimization, the best-case time complexity can reach $O(n)$.
+- **Space complexity of $O(1)$, in-place sorting**: Pointers $i$ and $j$ use a constant amount of extra space.
+- **Stable sorting**: Since equal elements are not swapped during "bubbling".
diff --git a/en/docs/chapter_sorting/bucket_sort.md b/en/docs/chapter_sorting/bucket_sort.md
index 0ff796b37..e0d617520 100644
--- a/en/docs/chapter_sorting/bucket_sort.md
+++ b/en/docs/chapter_sorting/bucket_sort.md
@@ -1,20 +1,20 @@
# Bucket sort
-The previously mentioned sorting algorithms are all "comparison-based sorting algorithms," which sort elements by comparing their values. Such sorting algorithms cannot have better time complexity of $O(n \log n)$. Next, we will discuss several "non-comparison sorting algorithms" that could achieve linear time complexity.
+The several sorting algorithms mentioned earlier all belong to "comparison-based sorting algorithms", which achieve sorting by comparing the size of elements. The time complexity of such sorting algorithms cannot exceed $O(n \log n)$. Next, we will explore several "non-comparison sorting algorithms", whose time complexity can reach linear order.
-Bucket sort is a typical application of the divide-and-conquer strategy. It works by setting up a series of ordered buckets, each containing a range of data, and distributing the input data evenly across these buckets. And then, the data in each bucket is sorted individually. Finally, the sorted data from all the buckets is merged in sequence to produce the final result.
+Bucket sort (bucket sort) is a typical application of the divide-and-conquer strategy. It works by setting up buckets with size order, each bucket corresponding to a data range, evenly distributing data to each bucket; then, sorting within each bucket separately; finally, merging all data in the order of the buckets.
-## Algorithm process
+## Algorithm flow
-Consider an array of length $n$, with float numbers in the range $[0, 1)$. The bucket sort process is illustrated in the figure below.
+Consider an array of length $n$, whose elements are floating-point numbers in the range $[0, 1)$. The flow of bucket sort is shown in the figure below.
-1. Initialize $k$ buckets and distribute $n$ elements into these $k$ buckets.
-2. Sort each bucket individually (using the built-in sorting function of the programming language).
-3. Merge the results in the order from the smallest to the largest bucket.
+1. Initialize $k$ buckets and distribute the $n$ elements into the $k$ buckets.
+2. Sort each bucket separately (here we use the built-in sorting function of the programming language).
+3. Merge the results in order from smallest to largest bucket.
-
+
-The code is shown as follows:
+The code is as follows:
```src
[file]{bucket_sort}-[class]{}-[func]{bucket_sort}
@@ -22,24 +22,24 @@ The code is shown as follows:
## Algorithm characteristics
-Bucket sort is suitable for handling very large data sets. For example, if the input data includes 1 million elements, and system memory limitations prevent loading all the data at the same time, you can divide the data into 1,000 buckets and sort each bucket separately before merging the results.
+Bucket sort is suitable for processing very large data volumes. For example, if the input data contains 1 million elements and system memory cannot load all the data at once, the data can be divided into 1000 buckets, each bucket sorted separately, and then the results merged.
-- **Time complexity is $O(n + k)$**: Assuming the elements are evenly distributed across the buckets, the number of elements in each bucket is $n/k$. Assuming sorting a single bucket takes $O(n/k \log(n/k))$ time, sorting all buckets takes $O(n \log(n/k))$ time. **When the number of buckets $k$ is relatively large, the time complexity approaches $O(n)$**. Merging the results requires traversing all buckets and elements, taking $O(n + k)$ time. In the worst case, all data is distributed into a single bucket, and sorting that bucket takes $O(n^2)$ time.
-- **Space complexity is $O(n + k)$, non-in-place sorting**: It requires additional space for $k$ buckets and a total of $n$ elements.
-- Whether bucket sort is stable depends on whether the sorting algorithm used within each bucket is stable.
+- **Time complexity of $O(n + k)$**: Assuming the elements are evenly distributed among the buckets, then the number of elements in each bucket is $\frac{n}{k}$. Assuming sorting a single bucket uses $O(\frac{n}{k} \log\frac{n}{k})$ time, then sorting all buckets uses $O(n \log\frac{n}{k})$ time. **When the number of buckets $k$ is relatively large, the time complexity approaches $O(n)$**. Merging results requires traversing all buckets and elements, taking $O(n + k)$ time. In the worst case, all data is distributed into one bucket, and sorting that bucket uses $O(n^2)$ time.
+- **Space complexity of $O(n + k)$, non-in-place sorting**: Additional space is required for $k$ buckets and a total of $n$ elements.
+- Whether bucket sort is stable depends on whether the algorithm for sorting elements within buckets is stable.
## How to achieve even distribution
-The theoretical time complexity of bucket sort can reach $O(n)$. **The key is to evenly distribute the elements across all buckets** as real-world data is often not uniformly distributed. For example, we may want to evenly distribute all products on eBay by price range into 10 buckets. However, the distribution of product prices may not be even, with many under $100 and few over $500. If the price range is evenly divided into 10, the difference in the number of products in each bucket will be significant.
+Theoretically, bucket sort can achieve $O(n)$ time complexity. **The key is to evenly distribute elements to each bucket**, because real data is often not evenly distributed. For example, if we want to evenly distribute all products on Taobao into 10 buckets by price range, there may be very many products below 100 yuan and very few above 1000 yuan. If the price intervals are evenly divided into 10, the difference in the number of products in each bucket will be very large.
-To achieve even distribution, we can initially set an approximate boundary to roughly divide the data into 3 buckets. **After the distribution is complete, the buckets with more items can be further divided into 3 buckets, until the number of elements in all buckets is roughly equal**.
+To achieve even distribution, we can first set an approximate dividing line to roughly divide the data into 3 buckets. **After distribution is complete, continue dividing buckets with more products into 3 buckets until the number of elements in all buckets is roughly equal**.
-As shown in the figure below, this method essentially constructs a recursive tree, aiming to ensure the element counts in leaf nodes are as even as possible. Of course, you don't have to divide the data into 3 buckets each round - the partitioning strategy can be adaptively tailored to the data's unique characteristics.
+As shown in the figure below, this method essentially creates a recursion tree, with the goal of making the values of leaf nodes as even as possible. Of course, it is not necessary to divide the data into 3 buckets every round; the specific division method can be flexibly chosen according to data characteristics.
-
+
-If we know the probability distribution of product prices in advance, **we can set the price boundaries for each bucket based on the data probability distribution**. It is worth noting that it is not necessarily required to specifically calculate the data distribution; instead, it can be approximated based on data characteristics using a probability model.
+If we know the probability distribution of product prices in advance, **we can set the price dividing line for each bucket based on the data probability distribution**. It is worth noting that the data distribution does not necessarily need to be specifically calculated, but can also be approximated using a certain probability model based on data characteristics.
-As shown in the figure below, assuming that product prices follow a normal distribution, we can define reasonable price intervals to balance the distribution of items across the buckets.
+As shown in the figure below, we assume that product prices follow a normal distribution, which allows us to reasonably set price intervals to evenly distribute products to each bucket.
diff --git a/en/docs/chapter_sorting/counting_sort.md b/en/docs/chapter_sorting/counting_sort.md
index 281b0d315..81a157a6a 100644
--- a/en/docs/chapter_sorting/counting_sort.md
+++ b/en/docs/chapter_sorting/counting_sort.md
@@ -1,18 +1,18 @@
# Counting sort
-Counting sort achieves sorting by counting the number of elements, usually applied to integer arrays.
+Counting sort (counting sort) achieves sorting by counting the number of elements, typically applied to integer arrays.
## Simple implementation
-Let's start with a simple example. Given an array `nums` of length $n$, where all elements are "non-negative integers", the overall process of counting sort is shown in the figure below.
+Let's start with a simple example. Given an array `nums` of length $n$, where the elements are all "non-negative integers", the overall flow of counting sort is shown in the figure below.
-1. Traverse the array to find the maximum number, denoted as $m$, then create an auxiliary array `counter` of length $m + 1$.
-2. **Use `counter` to count the occurrence of each number in `nums`**, where `counter[num]` corresponds to the occurrence of the number `num`. The counting method is simple, just traverse `nums` (suppose the current number is `num`), and increase `counter[num]` by $1$ each round.
-3. **Since the indices of `counter` are naturally ordered, all numbers are essentially sorted already**. Next, we traverse `counter`, and fill in `nums` in ascending order of occurrence.
+1. Traverse the array to find the largest number, denoted as $m$, and then create an auxiliary array `counter` of length $m + 1$.
+2. **Use `counter` to count the number of occurrences of each number in `nums`**, where `counter[num]` corresponds to the number of occurrences of the number `num`. The counting method is simple: just traverse `nums` (let the current number be `num`), and increase `counter[num]` by $1$ in each round.
+3. **Since each index of `counter` is naturally ordered, this is equivalent to all numbers being sorted**. Next, we traverse `counter` and fill in `nums` in ascending order based on the number of occurrences of each number.
-
+
-The code is shown below:
+The code is as follows:
```src
[file]{counting_sort}-[class]{}-[func]{counting_sort_naive}
@@ -20,27 +20,27 @@ The code is shown below:
!!! note "Connection between counting sort and bucket sort"
- From the perspective of bucket sort, we can consider each index of the counting array `counter` in counting sort as a bucket, and the process of counting as distributing elements into the corresponding buckets. Essentially, counting sort is a special case of bucket sort for integer data.
+ From the perspective of bucket sort, we can regard each index of the counting array `counter` in counting sort as a bucket, and the process of counting quantities as distributing each element to the corresponding bucket. Essentially, counting sort is a special case of bucket sort for integer data.
## Complete implementation
-Observant readers might notice, **if the input data is an object, the above step `3.` is invalid**. Suppose the input data is a product object, we want to sort the products by the price (a class member variable), but the above algorithm can only give the sorted price as the result.
+Observant readers may have noticed that **if the input data is objects, step `3.` above becomes invalid**. Suppose the input data is product objects, and we want to sort the products by price (a member variable of the class), but the above algorithm can only give the sorting result of prices.
-So how can we get the sorting result for the original data? First, we calculate the "prefix sum" of `counter`. As the name suggests, the prefix sum at index `i`, `prefix[i]`, equals the sum of the first `i` elements of the array:
+So how can we obtain the sorting result of the original data? We first calculate the "prefix sum" of `counter`. As the name suggests, the prefix sum at index `i`, `prefix[i]`, equals the sum of the first `i` elements of the array:
$$
\text{prefix}[i] = \sum_{j=0}^i \text{counter[j]}
$$
-**The prefix sum has a clear meaning, `prefix[num] - 1` represents the index of the last occurrence of element `num` in the result array `res`**. This information is crucial, as it tells us where each element should appear in the result array. Next, we traverse each element `num` of the original array `nums` in reverse order, performing the following two steps in each iteration.
+**The prefix sum has a clear meaning: `prefix[num] - 1` represents the index of the last occurrence of element `num` in the result array `res`**. This information is very critical because it tells us where each element should appear in the result array. Next, we traverse each element `num` of the original array `nums` in reverse order, performing the following two steps in each iteration.
-1. Fill `num` into the array `res` at the index `prefix[num] - 1`.
-2. Decrease the prefix sum `prefix[num]` by $1$ to obtain the next index to place `num`.
+1. Fill `num` into the array `res` at index `prefix[num] - 1`.
+2. Decrease the prefix sum `prefix[num]` by $1$ to get the index for the next placement of `num`.
-After the traversal, the array `res` contains the sorted result, and finally, `res` replaces the original array `nums`. The complete counting sort process is shown in the figure below.
+After the traversal is complete, the array `res` contains the sorted result, and finally `res` is used to overwrite the original array `nums`. The complete counting sort flow is shown in the figure below.
=== "<1>"
- 
+ 
=== "<2>"
@@ -63,7 +63,7 @@ After the traversal, the array `res` contains the sorted result, and finally, `r
=== "<8>"
-The implementation code of counting sort is shown below:
+The implementation code of counting sort is as follows:
```src
[file]{counting_sort}-[class]{}-[func]{counting_sort}
@@ -71,14 +71,14 @@ The implementation code of counting sort is shown below:
## Algorithm characteristics
-- **Time complexity is $O(n + m)$, non-adaptive sort**: It involves traversing `nums` and `counter`, both using linear time. Generally, $n \gg m$, and the time complexity tends towards $O(n)$.
-- **Space complexity is $O(n + m)$, non-in-place sort**: It uses array `res` of lengths $n$ and array `counter` of length $m$ respectively.
-- **Stable sort**: Since elements are filled into `res` in a "right-to-left" order, reversing the traversal of `nums` can prevent changing the relative position between equal elements, thereby achieving a stable sort. Actually, traversing `nums` in order can also produce the correct sorting result, but the outcome is unstable.
+- **Time complexity of $O(n + m)$, non-adaptive sorting**: Involves traversing `nums` and traversing `counter`, both using linear time. Generally, $n \gg m$, and time complexity tends toward $O(n)$.
+- **Space complexity of $O(n + m)$, non-in-place sorting**: Uses arrays `res` and `counter` of lengths $n$ and $m$ respectively.
+- **Stable sorting**: Since elements are filled into `res` in a "right-to-left" order, traversing `nums` in reverse can avoid changing the relative positions of equal elements, thereby achieving stable sorting. In fact, traversing `nums` in forward order can also yield correct sorting results, but the result would be unstable.
## Limitations
-By now, you might find counting sort very clever, as it can achieve efficient sorting merely by counting quantities. However, the prerequisites for using counting sort are relatively strict.
+By this point, you might think counting sort is very clever, as it can achieve efficient sorting just by counting quantities. However, the prerequisites for using counting sort are relatively strict.
-**Counting sort is only suitable for non-negative integers**. If you want to apply it to other types of data, you need to ensure that these data can be converted to non-negative integers without changing the original order of the elements. For example, for an array containing negative integers, you can first add a constant to all numbers, converting them all to positive numbers, and then convert them back after sorting is complete.
+**Counting sort is only suitable for non-negative integers**. If you want to apply it to other types of data, you need to ensure that the data can be converted to non-negative integers without changing the relative size relationships between elements. For example, for an integer array containing negative numbers, you can first add a constant to all numbers to convert them all to positive numbers, and then convert them back after sorting is complete.
-**Counting sort is suitable for large datasets with a small range of values**. For example, in the above example, $m$ should not be too large, otherwise, it will occupy too much space. And when $n \ll m$, counting sort uses $O(m)$ time, which may be slower than $O(n \log n)$ sorting algorithms.
+**Counting sort is suitable for situations where the data volume is large but the data range is small**. For example, in the above example, $m$ cannot be too large, otherwise it will occupy too much space. And when $n \ll m$, counting sort uses $O(m)$ time, which may be slower than $O(n \log n)$ sorting algorithms.
diff --git a/en/docs/chapter_sorting/heap_sort.md b/en/docs/chapter_sorting/heap_sort.md
index 0a735056a..18415f78e 100644
--- a/en/docs/chapter_sorting/heap_sort.md
+++ b/en/docs/chapter_sorting/heap_sort.md
@@ -4,28 +4,28 @@
Before reading this section, please ensure you have completed the "Heap" chapter.
-Heap sort is an efficient sorting algorithm based on the heap data structure. We can implement heap sort using the "heap creation" and "element extraction" operations we have already learned.
+Heap sort (heap sort) is an efficient sorting algorithm based on the heap data structure. We can use the "build heap operation" and "element out-heap operation" that we have already learned to implement heap sort.
-1. Input the array and construct a min-heap, where the smallest element is at the top of the heap.
-2. Continuously perform the extraction operation, record the extracted elements sequentially to obtain a sorted list from smallest to largest.
+1. Input the array and build a min-heap, at which point the smallest element is at the heap top.
+2. Continuously perform the out-heap operation, record the out-heap elements in sequence, and an ascending sorted sequence can be obtained.
-Although the above method is feasible, it requires an additional array to store the popped elements, which is somewhat space-consuming. In practice, we usually use a more elegant implementation.
+Although the above method is feasible, it requires an additional array to save the popped elements, which is quite wasteful of space. In practice, we usually use a more elegant implementation method.
## Algorithm flow
-Suppose the array length is $n$, the heap sort process is as follows.
+Assume the array length is $n$. The flow of heap sort is shown in the figure below.
-1. Input the array and establish a max-heap. After this step, the largest element is positioned at the top of the heap.
-2. Swap the top element of the heap (the first element) with the heap's bottom element (the last element). Following this swap, reduce the heap's length by $1$ and increase the sorted elements count by $1$.
-3. Starting from the heap top, perform the sift-down operation from top to bottom. After the sift-down, the heap's property is restored.
-4. Repeat steps `2.` and `3.` Loop for $n - 1$ rounds to complete the sorting of the array.
+1. Input the array and build a max-heap. After completion, the largest element is at the heap top.
+2. Swap the heap top element (first element) with the heap bottom element (last element). After the swap is complete, reduce the heap length by $1$ and increase the count of sorted elements by $1$.
+3. Starting from the heap top element, perform top-to-bottom heapify operation (sift down). After heapify is complete, the heap property is restored.
+4. Loop through steps `2.` and `3.` After looping $n - 1$ rounds, the array sorting can be completed.
!!! tip
- In fact, the element extraction operation also includes steps `2.` and `3.`, with an additional step to pop (remove) the extracted element from the heap.
+ In fact, the element out-heap operation also includes steps `2.` and `3.`, with just an additional step to pop the element.
=== "<1>"
- 
+ 
=== "<2>"
@@ -60,7 +60,7 @@ Suppose the array length is $n$, the heap sort process is as follows.
=== "<12>"
-In the code implementation, we used the sift-down function `sift_down()` from the "Heap" chapter. It is important to note that since the heap's length decreases as the maximum element is extracted, we need to add a length parameter $n$ to the `sift_down()` function to specify the current effective length of the heap. The code is shown below:
+In the code implementation, we use the same top-to-bottom heapify function `sift_down()` from the "Heap" chapter. It is worth noting that since the heap length will decrease as the largest element is extracted, we need to add a length parameter $n$ to the `sift_down()` function to specify the current effective length of the heap. The code is as follows:
```src
[file]{heap_sort}-[class]{}-[func]{heap_sort}
@@ -68,6 +68,6 @@ In the code implementation, we used the sift-down function `sift_down()` from th
## Algorithm characteristics
-- **Time complexity is $O(n \log n)$, non-adaptive sort**: The heap creation uses $O(n)$ time. Extracting the largest element from the heap takes $O(\log n)$ time, looping for $n - 1$ rounds.
-- **Space complexity is $O(1)$, in-place sort**: A few pointer variables use $O(1)$ space. The element swapping and heapifying operations are performed on the original array.
-- **Non-stable sort**: The relative positions of equal elements may change during the swapping of the heap's top and bottom elements.
+- **Time complexity of $O(n \log n)$, non-adaptive sorting**: The build heap operation uses $O(n)$ time. Extracting the largest element from the heap has a time complexity of $O(\log n)$, looping a total of $n - 1$ rounds.
+- **Space complexity of $O(1)$, in-place sorting**: A few pointer variables use $O(1)$ space. Element swapping and heapify operations are both performed on the original array.
+- **Non-stable sorting**: When swapping the heap top element and heap bottom element, the relative positions of equal elements may change.
diff --git a/en/docs/chapter_sorting/index.md b/en/docs/chapter_sorting/index.md
index 6694befbd..80fca2401 100644
--- a/en/docs/chapter_sorting/index.md
+++ b/en/docs/chapter_sorting/index.md
@@ -4,6 +4,6 @@
!!! abstract
- Sorting is like a magical key that turns chaos into order, enabling us to understand and handle data more efficiently.
+ Sorting is like a magic key that transforms chaos into order, enabling us to understand and process data more efficiently.
- Whether it's simple ascending order or complex categorical arrangements, sorting reveals the harmonious beauty of data.
+ Whether it's simple ascending order or complex categorized arrangements, sorting demonstrates the harmonious beauty of data.
diff --git a/en/docs/chapter_sorting/insertion_sort.md b/en/docs/chapter_sorting/insertion_sort.md
index aca1f8af1..19c9bbb55 100644
--- a/en/docs/chapter_sorting/insertion_sort.md
+++ b/en/docs/chapter_sorting/insertion_sort.md
@@ -1,23 +1,23 @@
# Insertion sort
-Insertion sort is a simple sorting algorithm that works very much like the process of manually sorting a deck of cards.
+Insertion sort (insertion sort) is a simple sorting algorithm that works very similarly to the process of manually organizing a deck of cards.
-Specifically, we select a base element from the unsorted interval, compare it with the elements in the sorted interval to its left, and insert the element into the correct position.
+Specifically, we select a base element from the unsorted interval, compare the element with elements in the sorted interval to its left one by one, and insert the element into the correct position.
-The figure below illustrates how an element is inserted into the array. Assuming the base element is `base`, we need to shift all elements from the target index up to `base` one position to the right, then assign `base` to the target index.
+The figure below shows the operation flow of inserting an element into the array. Let the base element be `base`. We need to move all elements from the target index to `base` one position to the right, and then assign `base` to the target index.
-## Algorithm process
+## Algorithm flow
-The overall process of insertion sort is shown in the figure below.
+The overall flow of insertion sort is shown in the figure below.
-1. Consider the first element of the array as sorted.
-2. Select the second element as `base`, insert it into its correct position, **leaving the first two elements sorted**.
-3. Select the third element as `base`, insert it into its correct position, **leaving the first three elements sorted**.
-4. Continuing in this manner, in the final iteration, the last element is taken as `base`, and after inserting it into the correct position, **all elements are sorted**.
+1. Initially, the first element of the array has completed sorting.
+2. Select the second element of the array as `base`, and after inserting it into the correct position, **the first 2 elements of the array are sorted**.
+3. Select the third element as `base`, and after inserting it into the correct position, **the first 3 elements of the array are sorted**.
+4. And so on. In the last round, select the last element as `base`, and after inserting it into the correct position, **all elements are sorted**.
-
+
Example code is as follows:
@@ -27,20 +27,20 @@ Example code is as follows:
## Algorithm characteristics
-- **Time complexity is $O(n^2)$, adaptive sorting**: In the worst case, each insertion operation requires $n - 1$, $n-2$, ..., $2$, $1$ loops, summing up to $(n - 1) n / 2$, thus the time complexity is $O(n^2)$. In the case of ordered data, the insertion operation will terminate early. When the input array is completely ordered, insertion sort achieves the best time complexity of $O(n)$.
-- **Space complexity is $O(1)$, in-place sorting**: Pointers $i$ and $j$ use a constant amount of extra space.
-- **Stable sorting**: During the insertion operation, we insert elements to the right of equal elements, not changing their order.
+- **Time complexity of $O(n^2)$, adaptive sorting**: In the worst case, each insertion operation requires loops of $n - 1$, $n-2$, $\dots$, $2$, $1$, summing to $(n - 1) n / 2$, so the time complexity is $O(n^2)$. When encountering ordered data, the insertion operation will terminate early. When the input array is completely ordered, insertion sort achieves the best-case time complexity of $O(n)$.
+- **Space complexity of $O(1)$, in-place sorting**: Pointers $i$ and $j$ use a constant amount of extra space.
+- **Stable sorting**: During the insertion operation process, we insert elements to the right of equal elements, without changing their order.
## Advantages of insertion sort
-The time complexity of insertion sort is $O(n^2)$, while the time complexity of quicksort, which we will study next, is $O(n \log n)$. Although insertion sort has a higher time complexity, **it is usually faster in small input sizes**.
+The time complexity of insertion sort is $O(n^2)$, while the time complexity of quick sort, which we will learn about next, is $O(n \log n)$. Although insertion sort has a higher time complexity, **insertion sort is usually faster for smaller data volumes**.
-This conclusion is similar to that for linear and binary search. Algorithms like quicksort that have a time complexity of $O(n \log n)$ and are based on the divide-and-conquer strategy often involve more unit operations. For small input sizes, the numerical values of $n^2$ and $n \log n$ are close, and complexity does not dominate, with the number of unit operations per round playing a decisive role.
+This conclusion is similar to the applicable situations of linear search and binary search. Algorithms like quick sort with $O(n \log n)$ complexity are sorting algorithms based on divide-and-conquer strategy and often contain more unit computation operations. When the data volume is small, $n^2$ and $n \log n$ are numerically close, and complexity does not dominate; the number of unit operations per round plays a decisive role.
-In fact, many programming languages (such as Java) use insertion sort within their built-in sorting functions. The general approach is: for long arrays, use sorting algorithms based on divide-and-conquer strategies, such as quicksort; for short arrays, use insertion sort directly.
+In fact, the built-in sorting functions in many programming languages (such as Java) adopt insertion sort. The general approach is: for long arrays, use sorting algorithms based on divide-and-conquer strategy, such as quick sort; for short arrays, directly use insertion sort.
-Although bubble sort, selection sort, and insertion sort all have a time complexity of $O(n^2)$, in practice, **insertion sort is commonly used than bubble sort and selection sort**, mainly for the following reasons.
+Although bubble sort, selection sort, and insertion sort all have a time complexity of $O(n^2)$, in actual situations, **insertion sort is used significantly more frequently than bubble sort and selection sort**, mainly for the following reasons.
-- Bubble sort is based on element swapping, which requires the use of a temporary variable, involving 3 unit operations; insertion sort is based on element assignment, requiring only 1 unit operation. Therefore, **the computational overhead of bubble sort is generally higher than that of insertion sort**.
-- The time complexity of selection sort is always $O(n^2)$. **Given a set of partially ordered data, insertion sort is usually more efficient than selection sort**.
+- Bubble sort is based on element swapping, requiring the use of a temporary variable, involving 3 unit operations; insertion sort is based on element assignment, requiring only 1 unit operation. Therefore, **the computational overhead of bubble sort is usually higher than that of insertion sort**.
+- Selection sort has a time complexity of $O(n^2)$ in any case. **If given a set of partially ordered data, insertion sort is usually more efficient than selection sort**.
- Selection sort is unstable and cannot be applied to multi-level sorting.
diff --git a/en/docs/chapter_sorting/merge_sort.md b/en/docs/chapter_sorting/merge_sort.md
index 7073ec387..0edd25c11 100644
--- a/en/docs/chapter_sorting/merge_sort.md
+++ b/en/docs/chapter_sorting/merge_sort.md
@@ -1,23 +1,23 @@
# Merge sort
-Merge sort is a sorting algorithm based on the divide-and-conquer strategy, involving the "divide" and "merge" phases shown in the figure below.
+Merge sort (merge sort) is a sorting algorithm based on the divide-and-conquer strategy, which includes the "divide" and "merge" phases shown in the figure below.
-1. **Divide phase**: Recursively split the array from the midpoint, transforming the sorting problem of a long array into shorter arrays.
-2. **Merge phase**: Stop dividing when the length of the sub-array is 1, and then begin merging. The two shorter sorted arrays are continuously merged into a longer sorted array until the process is complete.
+1. **Divide phase**: Recursively split the array from the midpoint, transforming the sorting problem of a long array into the sorting problems of shorter arrays.
+2. **Merge phase**: When the sub-array length is 1, terminate the division and start merging, continuously merging two shorter sorted arrays into one longer sorted array until the process is complete.
-
+
-## Algorithm workflow
+## Algorithm flow
As shown in the figure below, the "divide phase" recursively splits the array from the midpoint into two sub-arrays from top to bottom.
-1. Calculate the midpoint `mid`, recursively divide the left sub-array (interval `[left, mid]`) and the right sub-array (interval `[mid + 1, right]`).
-2. Continue with step `1.` recursively until sub-array length becomes 1, then stops.
+1. Calculate the array midpoint `mid`, recursively divide the left sub-array (interval `[left, mid]`) and right sub-array (interval `[mid + 1, right]`).
+2. Recursively execute step `1.` until the sub-array interval length is 1, then terminate.
-The "merge phase" combines the left and right sub-arrays into a sorted array from bottom to top. It is important to note that, merging starts with sub-arrays of length 1, and each sub-array is sorted during the merge phase.
+The "merge phase" merges the left sub-array and right sub-array into a sorted array from bottom to top. Note that merging starts from sub-arrays of length 1, and each sub-array in the merge phase is sorted.
=== "<1>"
- 
+ 
=== "<2>"
@@ -46,12 +46,12 @@ The "merge phase" combines the left and right sub-arrays into a sorted array fro
=== "<10>"
-It can be observed that the order of recursion in merge sort is consistent with the post-order traversal of a binary tree.
+It can be observed that the recursive order of merge sort is consistent with the post-order traversal of a binary tree.
-- **Post-order traversal**: First recursively traverse the left subtree, then the right subtree, and finally process the root node.
-- **Merge sort**: First recursively process the left sub-array, then the right sub-array, and finally perform the merge.
+- **Post-order traversal**: First recursively traverse the left subtree, then recursively traverse the right subtree, and finally process the root node.
+- **Merge sort**: First recursively process the left sub-array, then recursively process the right sub-array, and finally perform the merge.
-The implementation of merge sort is shown in the following code. Note that the interval to be merged in `nums` is `[left, right]`, while the corresponding interval in `tmp` is `[0, right - left]`.
+The implementation of merge sort is shown in the code below. Note that the interval to be merged in `nums` is `[left, right]`, while the corresponding interval in `tmp` is `[0, right - left]`.
```src
[file]{merge_sort}-[class]{}-[func]{merge_sort}
@@ -59,15 +59,15 @@ The implementation of merge sort is shown in the following code. Note that the i
## Algorithm characteristics
-- **Time complexity of $O(n \log n)$, non-adaptive sort**: The division creates a recursion tree of height $\log n$, with each layer merging a total of $n$ operations, resulting in an overall time complexity of $O(n \log n)$.
-- **Space complexity of $O(n)$, non-in-place sort**: The recursion depth is $\log n$, using $O(\log n)$ stack frame space. The merging operation requires auxiliary arrays, using an additional space of $O(n)$.
-- **Stable sort**: During the merging process, the order of equal elements remains unchanged.
+- **Time complexity of $O(n \log n)$, non-adaptive sorting**: The division produces a recursion tree of height $\log n$, and the total number of merge operations at each level is $n$, so the overall time complexity is $O(n \log n)$.
+- **Space complexity of $O(n)$, non-in-place sorting**: The recursion depth is $\log n$, using $O(\log n)$ size of stack frame space. The merge operation requires the aid of an auxiliary array, using $O(n)$ size of additional space.
+- **Stable sorting**: In the merge process, the order of equal elements remains unchanged.
-## Linked List sorting
+## Linked list sorting
-For linked lists, merge sort has significant advantages over other sorting algorithms. **It can optimize the space complexity of the linked list sorting task to $O(1)$**.
+For linked lists, merge sort has significant advantages over other sorting algorithms, **and can optimize the space complexity of linked list sorting tasks to $O(1)$**.
-- **Divide phase**: "Iteration" can be used instead of "recursion" to perform the linked list division work, thus saving the stack frame space used by recursion.
-- **Merge phase**: In linked lists, node insertion and deletion operations can be achieved by changing references (pointers), so no extra lists need to be created during the merge phase (combining two short ordered lists into one long ordered list).
+- **Divide phase**: "Iteration" can be used instead of "recursion" to implement linked list division work, thus saving the stack frame space used by recursion.
+- **Merge phase**: In linked lists, node insertion and deletion operations can be achieved by just changing references (pointers), so there is no need to create additional linked lists during the merge phase (merging two short ordered linked lists into one long ordered linked list).
-The implementation details are relatively complex, and interested readers can consult related materials for learning.
+The specific implementation details are quite complex, and interested readers can consult related materials for learning.
diff --git a/en/docs/chapter_sorting/quick_sort.md b/en/docs/chapter_sorting/quick_sort.md
index 9ca1df7b9..cfc0121fa 100644
--- a/en/docs/chapter_sorting/quick_sort.md
+++ b/en/docs/chapter_sorting/quick_sort.md
@@ -1,15 +1,15 @@
# Quick sort
-Quick sort is a sorting algorithm based on the divide-and-conquer strategy, known for its efficiency and wide application.
+Quick sort (quick sort) is a sorting algorithm based on the divide-and-conquer strategy, which operates efficiently and is widely applied.
-The core operation of quick sort is "pivot partitioning," which aims to select an element from the array as the "pivot" and move all elements less than the pivot to its left side, while moving all elements greater than the pivot to its right side. Specifically, the process of pivot partitioning is illustrated in the figure below.
+The core operation of quick sort is "sentinel partitioning", which aims to: select a certain element in the array as the "pivot", move all elements smaller than the pivot to its left, and move elements larger than the pivot to its right. Specifically, the flow of sentinel partitioning is shown in the figure below.
-1. Select the leftmost element of the array as the pivot, and initialize two pointers `i` and `j` to point to the two ends of the array respectively.
-2. Set up a loop where each round uses `i` (`j`) to search for the first element larger (smaller) than the pivot, then swap these two elements.
-3. Repeat step `2.` until `i` and `j` meet, finally swap the pivot to the boundary between the two sub-arrays.
+1. Select the leftmost element of the array as the pivot, and initialize two pointers `i` and `j` pointing to the two ends of the array.
+2. Set up a loop in which `i` (`j`) is used in each round to find the first element larger (smaller) than the pivot, and then swap these two elements.
+3. Loop through step `2.` until `i` and `j` meet, and finally swap the pivot to the boundary line of the two sub-arrays.
=== "<1>"
- 
+ 
=== "<2>"
@@ -35,66 +35,65 @@ The core operation of quick sort is "pivot partitioning," which aims to select a
=== "<9>"
-After the pivot partitioning, the original array is divided into three parts: left sub-array, pivot, and right sub-array, satisfying "any element in the left sub-array $\leq$ pivot $\leq$ any element in the right sub-array." Therefore, we then only need to sort these two sub-arrays.
+After sentinel partitioning is complete, the original array is divided into three parts: left sub-array, pivot, right sub-array, satisfying "any element in left sub-array $\leq$ pivot $\leq$ any element in right sub-array". Therefore, we next only need to sort these two sub-arrays.
-!!! note "Divide-and-conquer strategy for quick sort"
+!!! note "Divide-and-conquer strategy of quick sort"
- The essence of pivot partitioning is to simplify the sorting problem of a longer array into two shorter arrays.
+ The essence of sentinel partitioning is to simplify the sorting problem of a longer array into the sorting problems of two shorter arrays.
```src
[file]{quick_sort}-[class]{quick_sort}-[func]{partition}
```
-## Algorithm process
+## Algorithm flow
-The overall process of quick sort is shown in the figure below.
+The overall flow of quick sort is shown in the figure below.
-1. First, perform a "pivot partitioning" on the original array to obtain the unsorted left and right sub-arrays.
-2. Then, recursively perform "pivot partitioning" on the left and right sub-arrays separately.
-3. Continue recursively until the length of sub-array is 1, thus completing the sorting of the entire array.
+1. First, perform one "sentinel partitioning" on the original array to obtain the unsorted left sub-array and right sub-array.
+2. Then, recursively perform "sentinel partitioning" on the left sub-array and right sub-array respectively.
+3. Continue recursively until the sub-array length is 1, at which point sorting of the entire array is complete.
-
+
```src
[file]{quick_sort}-[class]{quick_sort}-[func]{quick_sort}
```
-## Algorithm features
+## Algorithm characteristics
-- **Time complexity of $O(n \log n)$, non-adaptive sorting**: In average cases, the recursive levels of pivot partitioning are $\log n$, and the total number of loops per level is $n$, using $O(n \log n)$ time overall. In the worst case, each round of pivot partitioning divides an array of length $n$ into two sub-arrays of lengths $0$ and $n - 1$, when the number of recursive levels reaches $n$, the number of loops in each level is $n$, and the total time used is $O(n^2)$.
-- **Space complexity of $O(n)$, in-place sorting**: In the case where the input array is completely reversed, the worst recursive depth reaches $n$, using $O(n)$ stack frame space. The sorting operation is performed on the original array without the aid of additional arrays.
-- **Non-stable sorting**: In the final step of pivot partitioning, the pivot may be swapped to the right of equal elements.
+- **Time complexity of $O(n \log n)$, non-adaptive sorting**: In the average case, the number of recursive levels of sentinel partitioning is $\log n$, and the total number of loops at each level is $n$, using $O(n \log n)$ time overall. In the worst case, each round of sentinel partitioning divides an array of length $n$ into two sub-arrays of length $0$ and $n - 1$, at which point the number of recursive levels reaches $n$, the number of loops at each level is $n$, and the total time used is $O(n^2)$.
+- **Space complexity of $O(n)$, in-place sorting**: In the case where the input array is completely reversed, the worst recursive depth reaches $n$, using $O(n)$ stack frame space. The sorting operation is performed on the original array without the aid of an additional array.
+- **Non-stable sorting**: In the last step of sentinel partitioning, the pivot may be swapped to the right of equal elements.
## Why is quick sort fast
-As the name suggests, quick sort should have certain advantages in terms of efficiency. Although the average time complexity of quick sort is the same as that of "merge sort" and "heap sort," it is generally more efficient for the following reasons.
+From the name, we can see that quick sort should have certain advantages in terms of efficiency. Although the average time complexity of quick sort is the same as "merge sort" and "heap sort", quick sort is usually more efficient, mainly for the following reasons.
-- **Low probability of worst-case scenarios**: Although the worst time complexity of quick sort is $O(n^2)$, less stable than merge sort, in most cases, quick sort can operate under a time complexity of $O(n \log n)$.
-- **High cache utilization**: During the pivot partitioning operation, the system can load the entire sub-array into the cache, thus accessing elements more efficiently. In contrast, algorithms like "heap sort" need to access elements in a jumping manner, lacking this feature.
-- **Small constant coefficient of complexity**: Among the three algorithms mentioned above, quick sort has the least total number of operations such as comparisons, assignments, and swaps. This is similar to why "insertion sort" is faster than "bubble sort."
+- **The probability of the worst case occurring is very low**: Although the worst-case time complexity of quick sort is $O(n^2)$, which is not as stable as merge sort, in the vast majority of cases, quick sort can run with a time complexity of $O(n \log n)$.
+- **High cache utilization**: When performing sentinel partitioning operations, the system can load the entire sub-array into the cache, so element access efficiency is relatively high. Algorithms like "heap sort" require jump-style access to elements, thus lacking this characteristic.
+- **Small constant coefficient of complexity**: Among the three algorithms mentioned above, quick sort has the smallest total number of operations such as comparisons, assignments, and swaps. This is similar to the reason why "insertion sort" is faster than "bubble sort".
## Pivot optimization
-**Quick sort's time efficiency may degrade under certain inputs**. For example, if the input array is completely reversed, since we select the leftmost element as the pivot, after the pivot partitioning, the pivot is swapped to the array's right end, causing the left sub-array length to be $n - 1$ and the right sub-array length to be $0$. Continuing this way, each round of pivot partitioning will have a sub-array length of $0$, and the divide-and-conquer strategy fails, degrading quick sort to a form similar to "bubble sort."
+**Quick sort may have reduced time efficiency for certain inputs**. Take an extreme example: suppose the input array is completely reversed. Since we select the leftmost element as the pivot, after sentinel partitioning is complete, the pivot is swapped to the rightmost end of the array, causing the left sub-array length to be $n - 1$ and the right sub-array length to be $0$. If we recurse down like this, each round of sentinel partitioning will have a sub-array length of $0$, the divide-and-conquer strategy fails, and quick sort degrades to a form approximate to "bubble sort".
-To avoid this situation, **we can optimize the pivot selection strategy in the pivot partitioning**. For instance, we can randomly select an element as the pivot. However, if luck is not on our side, and we consistently select suboptimal pivots, the efficiency is still not satisfactory.
+To avoid this situation as much as possible, **we can optimize the pivot selection strategy in sentinel partitioning**. For example, we can randomly select an element as the pivot. However, if luck is not good and we select a non-ideal pivot every time, efficiency is still not satisfactory.
-It's important to note that programming languages usually generate "pseudo-random numbers". If we construct a specific test case for a pseudo-random number sequence, the efficiency of quick sort may still degrade.
+It should be noted that programming languages usually generate "pseudo-random numbers". If we construct a specific test case for a pseudo-random number sequence, the efficiency of quick sort may still degrade.
-For further improvement, we can select three candidate elements (usually the first, last, and midpoint elements of the array), **and use the median of these three candidate elements as the pivot**. This way, the probability that the pivot is "neither too small nor too large" will be greatly increased. Of course, we can also select more candidate elements to further enhance robustness of the algorithm. With this method, the probability of the time complexity degrading to $O(n^2)$ is greatly reduced.
+For further improvement, we can select three candidate elements in the array (usually the first, last, and middle elements of the array), **and use the median of these three candidate elements as the pivot**. In this way, the probability that the pivot is "neither too small nor too large" will be greatly increased. Of course, we can also select more candidate elements to further improve the robustness of the algorithm. After adopting this method, the probability of time complexity degrading to $O(n^2)$ is greatly reduced.
-Sample code is as follows:
+Example code is as follows:
```src
[file]{quick_sort}-[class]{quick_sort_median}-[func]{partition}
```
-## Tail recursion optimization
+## Recursive depth optimization
-**Under certain inputs, quick sort may occupy more space**. For example, consider a completely ordered input array. Let the length of the sub-array in the recursion be $m$. In each round of pivot partitioning, a left sub-array of length $0$ and a right sub-array of length $m - 1$ are produced. This means that the problem size is reduced by only one element per recursive call, resulting in a very small reduction at each level of recursion.
-As a result, the height of the recursion tree can reach $n − 1$ , which requires $O(n)$ of stack frame space.
+**For certain inputs, quick sort may occupy more space**. Taking a completely ordered input array as an example, let the length of the sub-array in recursion be $m$. Each round of sentinel partitioning will produce a left sub-array of length $0$ and a right sub-array of length $m - 1$, which means that the problem scale reduced per recursive call is very small (only one element is reduced), and the height of the recursion tree will reach $n - 1$, at which point $O(n)$ size of stack frame space is required.
-To prevent the accumulation of stack frame space, we can compare the lengths of the two sub-arrays after each round of pivot sorting, **and only recursively sort the shorter sub-array**. Since the length of the shorter sub-array will not exceed $n / 2$, this method ensures that the recursion depth does not exceed $\log n$, thus optimizing the worst space complexity to $O(\log n)$. The code is as follows:
+To prevent the accumulation of stack frame space, we can compare the lengths of the two sub-arrays after each round of sentinel sorting is complete, **and only recurse on the shorter sub-array**. Since the length of the shorter sub-array will not exceed $n / 2$, this method can ensure that the recursion depth does not exceed $\log n$, thus optimizing the worst-case space complexity to $O(\log n)$. The code is as follows:
```src
[file]{quick_sort}-[class]{quick_sort_tail_call}-[func]{quick_sort}
diff --git a/en/docs/chapter_sorting/radix_sort.md b/en/docs/chapter_sorting/radix_sort.md
index 08612d796..39b9dff77 100644
--- a/en/docs/chapter_sorting/radix_sort.md
+++ b/en/docs/chapter_sorting/radix_sort.md
@@ -1,41 +1,41 @@
# Radix sort
-The previous section introduced counting sort, which is suitable for scenarios where the data size $n$ is large but the data range $m$ is small. Suppose we need to sort $n = 10^6$ student IDs, where each ID is an $8$-digit number. This means the data range $m = 10^8$ is very large. Using counting sort in this case would require significant memory space. Radix sort can avoid this situation.
+The previous section introduced counting sort, which is suitable for situations where the data volume $n$ is large but the data range $m$ is small. Suppose we need to sort $n = 10^6$ student IDs, and the student ID is an 8-digit number, which means the data range $m = 10^8$ is very large. Using counting sort would require allocating a large amount of memory space, whereas radix sort can avoid this situation.
-Radix sort shares the same core concept as counting sort, which also sorts by counting the frequency of elements. Meanwhile, radix sort builds upon this by utilizing the progressive relationship between the digits of numbers. It processes and sorts the digits one at a time, achieving the final sorted order.
+Radix sort (radix sort) has a core idea consistent with counting sort, which also achieves sorting by counting quantities. Building on this, radix sort utilizes the progressive relationship between the digits of numbers, sorting each digit in turn to obtain the final sorting result.
-## Algorithm process
+## Algorithm flow
-Taking the student ID data as an example, assume the least significant digit is the $1^{st}$ and the most significant is the $8^{th}$, the radix sort process is illustrated in the figure below.
+Taking student ID data as an example, assume the lowest digit is the $1$st digit and the highest digit is the $8$th digit. The flow of radix sort is shown in the figure below.
-1. Initialize digit $k = 1$.
-2. Perform "counting sort" on the $k^{th}$ digit of the student IDs. After completion, the data will be sorted from smallest to largest based on the $k^{th}$ digit.
-3. Increment $k$ by $1$, then return to step `2.` and continue iterating until all digits have been sorted, at which point the process ends.
+1. Initialize the digit $k = 1$.
+2. Perform "counting sort" on the $k$th digit of the student IDs. After completion, the data will be sorted from smallest to largest according to the $k$th digit.
+3. Increase $k$ by $1$, then return to step `2.` and continue iterating until all digits are sorted, at which point the process ends.
-
+
-Below we dissect the code implementation. For a number $x$ in base $d$, to obtain its $k^{th}$ digit $x_k$, the following calculation formula can be used:
+Below we analyze the code implementation. For a $d$-base number $x$, to get its $k$th digit $x_k$, the following calculation formula can be used:
$$
x_k = \lfloor\frac{x}{d^{k-1}}\rfloor \bmod d
$$
-Where $\lfloor a \rfloor$ denotes rounding down the floating point number $a$, and $\bmod \: d$ denotes taking the modulus of $d$. For student ID data, $d = 10$ and $k \in [1, 8]$.
+Where $\lfloor a \rfloor$ denotes rounding down the floating-point number $a$, and $\bmod \: d$ denotes taking the modulo (remainder) with respect to $d$. For student ID data, $d = 10$ and $k \in [1, 8]$.
-Additionally, we need to slightly modify the counting sort code to allow sorting based on the $k^{th}$ digit:
+Additionally, we need to slightly modify the counting sort code to make it sort based on the $k$th digit of the number:
```src
[file]{radix_sort}-[class]{}-[func]{radix_sort}
```
-!!! question "Why start sorting from the least significant digit?"
+!!! question "Why start sorting from the lowest digit?"
- In consecutive sorting rounds, the result of a later round will override the result of an earlier round. For example, if the result of the first round is $a < b$ and the second round is $a > b$, the second round's result will replace the first round's result. Since higher-order digits take precedence over lower-order digits, it makes sense to sort the lower digits before the higher digits.
+ In successive sorting rounds, the result of a later round will override the result of an earlier round. For example, if the first round result is $a < b$, while the second round result is $a > b$, then the second round's result will replace the first round's result. Since higher-order digits have higher priority than lower-order digits, we should sort the lower digits first and then sort the higher digits.
## Algorithm characteristics
-Compared to counting sort, radix sort is suitable for larger numerical ranges, **but it assumes that the data can be represented in a fixed number of digits, and the number of digits should not be too large**. For example, floating-point numbers are unsuitable for radix sort, as their digit count $k$ may be large, potentially leading to a time complexity $O(nk) \gg O(n^2)$.
+Compared to counting sort, radix sort is suitable for larger numerical ranges, **but the prerequisite is that the data must be representable in a fixed number of digits, and the number of digits should not be too large**. For example, floating-point numbers are not suitable for radix sort because their number of digits $k$ may be too large, potentially leading to time complexity $O(nk) \gg O(n^2)$.
-- **Time complexity is $O(nk)$, non-adaptive sorting**: Assuming the data size is $n$, the data is in base $d$, and the maximum number of digits is $k$, then sorting a single digit takes $O(n + d)$ time, and sorting all $k$ digits takes $O((n + d)k)$ time. Generally, both $d$ and $k$ are relatively small, leading to a time complexity approaching $O(n)$.
-- **Space complexity is $O(n + d)$, non-in-place sorting**: Like counting sort, radix sort relies on arrays `res` and `counter` of lengths $n$ and $d$ respectively.
-- **Stable sorting**: When counting sort is stable, radix sort is also stable; if counting sort is unstable, radix sort cannot ensure a correct sorting order.
+- **Time complexity of $O(nk)$, non-adaptive sorting**: Let the data volume be $n$, the data be in base $d$, and the maximum number of digits be $k$. Then performing counting sort on a certain digit uses $O(n + d)$ time, and sorting all $k$ digits uses $O((n + d)k)$ time. Typically, both $d$ and $k$ are relatively small, and the time complexity approaches $O(n)$.
+- **Space complexity of $O(n + d)$, non-in-place sorting**: Same as counting sort, radix sort requires auxiliary arrays `res` and `counter` of lengths $n$ and $d$.
+- **Stable sorting**: When counting sort is stable, radix sort is also stable; when counting sort is unstable, radix sort cannot guarantee obtaining correct sorting results.
diff --git a/en/docs/chapter_sorting/selection_sort.md b/en/docs/chapter_sorting/selection_sort.md
index 3b62a435b..03af7d454 100644
--- a/en/docs/chapter_sorting/selection_sort.md
+++ b/en/docs/chapter_sorting/selection_sort.md
@@ -1,17 +1,17 @@
# Selection sort
-Selection sort works on a very simple principle: it uses a loop where each iteration selects the smallest element from the unsorted interval and moves it to the end of the sorted section.
+Selection sort (selection sort) works very simply: it opens a loop, and in each round, selects the smallest element from the unsorted interval and places it at the end of the sorted interval.
-Suppose the length of the array is $n$, the steps of selection sort is shown in the figure below.
+Assume the array has length $n$. The algorithm flow of selection sort is shown in the figure below.
1. Initially, all elements are unsorted, i.e., the unsorted (index) interval is $[0, n-1]$.
-2. Select the smallest element in the interval $[0, n-1]$ and swap it with the element at index $0$. After this, the first element of the array is sorted.
-3. Select the smallest element in the interval $[1, n-1]$ and swap it with the element at index $1$. After this, the first two elements of the array are sorted.
-4. Continue in this manner. After $n - 1$ rounds of selection and swapping, the first $n - 1$ elements are sorted.
-5. The only remaining element is subsequently the largest element and does not need sorting, thus the array is sorted.
+2. Select the smallest element in the interval $[0, n-1]$ and swap it with the element at index $0$. After completion, the first element of the array is sorted.
+3. Select the smallest element in the interval $[1, n-1]$ and swap it with the element at index $1$. After completion, the first 2 elements of the array are sorted.
+4. And so on. After $n - 1$ rounds of selection and swapping, the first $n - 1$ elements of the array are sorted.
+5. The only remaining element must be the largest element, requiring no sorting, so the array sorting is complete.
=== "<1>"
- 
+ 
=== "<2>"
@@ -51,8 +51,8 @@ In the code, we use $k$ to record the smallest element within the unsorted inter
## Algorithm characteristics
-- **Time complexity of $O(n^2)$, non-adaptive sort**: There are $n - 1$ iterations in the outer loop, with the length of the unsorted section starting at $n$ in the first iteration and decreasing to $2$ in the last iteration, i.e., each outer loop iterations contain $n$, $n - 1$, $\dots$, $3$, $2$ inner loop iterations respectively, summing up to $\frac{(n - 1)(n + 2)}{2}$.
-- **Space complexity of $O(1)$, in-place sort**: Uses constant extra space with pointers $i$ and $j$.
-- **Non-stable sort**: As shown in the figure below, an element `nums[i]` may be swapped to the right of an equal element, causing their relative order to change.
+- **Time complexity of $O(n^2)$, non-adaptive sorting**: The outer loop has $n - 1$ rounds in total. The length of the unsorted interval in the first round is $n$, and the length of the unsorted interval in the last round is $2$. That is, each round of the outer loop contains $n$, $n - 1$, $\dots$, $3$, $2$ inner loop iterations, summing to $\frac{(n - 1)(n + 2)}{2}$.
+- **Space complexity of $O(1)$, in-place sorting**: Pointers $i$ and $j$ use a constant amount of extra space.
+- **Non-stable sorting**: As shown in the figure below, element `nums[i]` may be swapped to the right of an element equal to it, causing a change in their relative order.
-
+
diff --git a/en/docs/chapter_sorting/sorting_algorithm.md b/en/docs/chapter_sorting/sorting_algorithm.md
index 5980af21c..d93ff3082 100644
--- a/en/docs/chapter_sorting/sorting_algorithm.md
+++ b/en/docs/chapter_sorting/sorting_algorithm.md
@@ -1,20 +1,20 @@
-# Sorting algorithms
+# Sorting algorithm
-Sorting algorithms are used to arrange a set of data in a specific order. Sorting algorithms have a wide range of applications because ordered data can usually be searched, analyzed, and processed more efficiently.
+Sorting algorithm (sorting algorithm) is used to arrange a group of data in a specific order. Sorting algorithms have extensive applications because ordered data can usually be searched, analyzed, and processed more efficiently.
-As shown in the figure below, the data types in sorting algorithms can be integers, floating point numbers, characters, or strings, etc. Sorting criterion can be set according to needs, such as numerical size, character ASCII order, or custom criterion.
+As shown in the figure below, data types in sorting algorithms can be integers, floating-point numbers, characters, or strings, etc. The sorting criterion can be set according to requirements, such as numerical size, character ASCII code order, or custom rules.
-
+
## Evaluation dimensions
-**Execution efficiency**: We expect the time complexity of sorting algorithms to be as low as possible, as well as a lower number of overall operations (lowering the constant term of time complexity). For large data volumes, execution efficiency is particularly important.
+**Execution efficiency**: We expect the time complexity of sorting algorithms to be as low as possible, with a smaller total number of operations (reducing the constant factor in time complexity). For large data volumes, execution efficiency is particularly important.
-**In-place property**: As the name implies, in-place sorting is achieved by directly manipulating the original array, without the need for additional helper arrays, thus saving memory. Generally, in-place sorting involves fewer data moving operations and is faster.
+**In-place property**: As the name implies, in-place sorting achieves sorting by operating directly on the original array without requiring additional auxiliary arrays, thus saving memory. Typically, in-place sorting involves fewer data movement operations and runs faster.
-**Stability**: Stable sorting ensures that the relative order of equal elements in the array does not change after sorting.
+**Stability**: Stable sorting ensures that the relative order of equal elements in the array does not change after sorting is completed.
-Stable sorting is a necessary condition for multi-key sorting scenarios. Suppose we have a table storing student information, with the first and second columns being name and age, respectively. In this case, unstable sorting might lead to a loss of order in the input data:
+Stable sorting is a necessary condition for multi-level sorting scenarios. Suppose we have a table storing student information, where column 1 and column 2 are name and age, respectively. In this case, unstable sorting may cause the ordered nature of the input data to be lost:
```shell
# Input data is sorted by name
@@ -25,9 +25,9 @@ Stable sorting is a necessary condition for multi-key sorting scenarios. Suppose
('D', 19)
('E', 23)
-# Assuming an unstable sorting algorithm is used to sort the list by age,
-# the result changes the relative position of ('D', 19) and ('A', 19),
-# and the property of the input data being sorted by name is lost
+# Assuming we use an unstable sorting algorithm to sort the list by age,
+# in the result, the relative positions of ('D', 19) and ('A', 19) are changed,
+# and the property that the input data is sorted by name is lost
('B', 18)
('D', 19)
('A', 19)
@@ -35,12 +35,12 @@ Stable sorting is a necessary condition for multi-key sorting scenarios. Suppose
('E', 23)
```
-**Adaptability**: Adaptive sorting leverages existing order information within the input data to reduce computational effort, achieving more optimal time efficiency. The best-case time complexity of adaptive sorting algorithms is typically better than their average-case time complexity.
+**Adaptability**: Adaptive sorting can utilize the existing order information in the input data to reduce the amount of computation, achieving better time efficiency. The best-case time complexity of adaptive sorting algorithms is typically better than the average time complexity.
-**Comparison or non-comparison-based**: Comparison-based sorting relies on comparison operators ($<$, $=$, $>$) to determine the relative order of elements and thus sort the entire array, with the theoretical optimal time complexity being $O(n \log n)$. Meanwhile, non-comparison sorting does not use comparison operators and can achieve a time complexity of $O(n)$, but its versatility is relatively poor.
+**Comparison-based or not**: Comparison-based sorting relies on comparison operators ($<$, $=$, $>$) to determine the relative order of elements, thereby sorting the entire array, with a theoretical optimal time complexity of $O(n \log n)$. Non-comparison sorting does not use comparison operators and can achieve a time complexity of $O(n)$, but its versatility is relatively limited.
## Ideal sorting algorithm
-**Fast execution, in-place, stable, adaptive, and versatile**. Clearly, no sorting algorithm that combines all these features has been found to date. Therefore, when selecting a sorting algorithm, it is necessary to decide based on the specific characteristics of the data and the requirements of the problem.
+**Fast execution, in-place, stable, adaptive, good versatility**. Clearly, no sorting algorithm has been discovered to date that combines all of these characteristics. Therefore, when selecting a sorting algorithm, it is necessary to decide based on the specific characteristics of the data and the requirements of the problem.
-Next, we will learn about various sorting algorithms together and analyze the advantages and disadvantages of each based on the above evaluation dimensions.
+Next, we will learn about various sorting algorithms together and analyze the advantages and disadvantages of each sorting algorithm based on the above evaluation dimensions.
diff --git a/en/docs/chapter_sorting/summary.md b/en/docs/chapter_sorting/summary.md
index e367d48ef..5ea33fb81 100644
--- a/en/docs/chapter_sorting/summary.md
+++ b/en/docs/chapter_sorting/summary.md
@@ -2,46 +2,46 @@
### Key review
-- Bubble sort works by swapping adjacent elements. By adding a flag to enable early return, we can optimize the best-case time complexity of bubble sort to $O(n)$.
-- Insertion sort sorts each round by inserting elements from the unsorted interval into the correct position in the sorted interval. Although the time complexity of insertion sort is $O(n^2)$, it is very popular in sorting small amounts of data due to relatively fewer operations per unit.
-- Quick sort is based on sentinel partitioning operations. In sentinel partitioning, it's possible to always pick the worst pivot, leading to a time complexity degradation to $O(n^2)$. Introducing median or random pivots can reduce the probability of such degradation. Tail recursion effectively reduce the recursion depth, optimizing the space complexity to $O(\log n)$.
-- Merge sort includes dividing and merging two phases, typically embodying the divide-and-conquer strategy. In merge sort, sorting an array requires creating auxiliary arrays, resulting in a space complexity of $O(n)$; however, the space complexity for sorting a list can be optimized to $O(1)$.
-- Bucket sort consists of three steps: distributing data into buckets, sorting within each bucket, and merging results in bucket order. It also embodies the divide-and-conquer strategy, suitable for very large datasets. The key to bucket sort is the even distribution of data.
-- Counting sort is a variant of bucket sort, which sorts by counting the occurrences of each data point. Counting sort is suitable for large datasets with a limited range of data and requires data conversion to positive integers.
-- Radix sort processes data by sorting it digit by digit, requiring data to be represented as fixed-length numbers.
-- Overall, we seek sorting algorithm that has high efficiency, stability, in-place operation, and adaptability. However, like other data structures and algorithms, no sorting algorithm can meet all these conditions simultaneously. In practical applications, we need to choose the appropriate sorting algorithm based on the characteristics of the data.
-- The figure below compares mainstream sorting algorithms in terms of efficiency, stability, in-place nature, and adaptability.
+- Bubble sort achieves sorting by swapping adjacent elements. By adding a flag to enable early return, we can optimize the best-case time complexity of bubble sort to $O(n)$.
+- Insertion sort completes sorting by inserting elements from the unsorted interval into the correct position in the sorted interval each round. Although the time complexity of insertion sort is $O(n^2)$, it is very popular in small data volume sorting tasks because it involves relatively few unit operations.
+- Quick sort is implemented based on sentinel partitioning operations. In sentinel partitioning, it is possible to select the worst pivot every time, causing the time complexity to degrade to $O(n^2)$. Introducing median pivot or random pivot can reduce the probability of such degradation. By preferentially recursing on the shorter sub-interval, the recursion depth can be effectively reduced, optimizing the space complexity to $O(\log n)$.
+- Merge sort includes two phases: divide and merge, which typically embody the divide-and-conquer strategy. In merge sort, sorting an array requires creating auxiliary arrays, with a space complexity of $O(n)$; however, the space complexity of sorting a linked list can be optimized to $O(1)$.
+- Bucket sort consists of three steps: distributing data into buckets, sorting within buckets, and merging results. It also embodies the divide-and-conquer strategy and is suitable for very large data volumes. The key to bucket sort is distributing data evenly.
+- Counting sort is a special case of bucket sort, which achieves sorting by counting the number of occurrences of data. Counting sort is suitable for situations where the data volume is large but the data range is limited, and requires that data can be converted to positive integers.
+- Radix sort achieves data sorting by sorting digit by digit, requiring that data can be represented as fixed-digit numbers.
+- Overall, we hope to find a sorting algorithm that is efficient, stable, in-place, and adaptive, with good versatility. However, just like other data structures and algorithms, no sorting algorithm has been found so far that simultaneously possesses all these characteristics. In practical applications, we need to select the appropriate sorting algorithm based on the specific characteristics of the data.
+- The figure below compares mainstream sorting algorithms in terms of efficiency, stability, in-place property, and adaptability.
-
+
### Q & A
-**Q**: When is the stability of sorting algorithms necessary?
+**Q**: In what situations is the stability of sorting algorithms necessary?
-In reality, we might sort based on one attribute of an object. For example, students have names and heights as attributes, and we aim to implement multi-level sorting: first by name to get `(A, 180) (B, 185) (C, 170) (D, 170)`; then by height. Because the sorting algorithm is unstable, we might end up with `(D, 170) (C, 170) (A, 180) (B, 185)`.
+In reality, we may sort based on a certain attribute of objects. For example, students have two attributes: name and height. We want to implement multi-level sorting: first sort by name to get `(A, 180) (B, 185) (C, 170) (D, 170)`; then sort by height. Because the sorting algorithm is unstable, we may get `(D, 170) (C, 170) (A, 180) (B, 185)`.
-It can be seen that the positions of students D and C have been swapped, disrupting the orderliness of the names, which is undesirable.
+It can be seen that the positions of students D and C have been swapped, and the orderliness of names has been disrupted, which is something we don't want to see.
**Q**: Can the order of "searching from right to left" and "searching from left to right" in sentinel partitioning be swapped?
-No, when using the leftmost element as the pivot, we must first "search from right to left" then "search from left to right". This conclusion is somewhat counterintuitive, so let's analyze the reason.
+No. When we use the leftmost element as the pivot, we must first "search from right to left" and then "search from left to right". This conclusion is somewhat counterintuitive; let's analyze the reason.
-The last step of the sentinel partition `partition()` is to swap `nums[left]` and `nums[i]`. After the swap, the elements to the left of the pivot are all `<=` the pivot, **which requires that `nums[left] >= nums[i]` must hold before the last swap**. Suppose we "search from left to right" first, and if no element larger than the pivot is found, **we will exit the loop when `i == j`, possibly with `nums[j] == nums[i] > nums[left]`**. In other words, the final swap operation will exchange an element larger than the pivot to the left end of the array, causing the sentinel partition to fail.
+The last step of sentinel partitioning `partition()` is to swap `nums[left]` and `nums[i]`. After the swap is complete, the elements to the left of the pivot are all `<=` the pivot, **which requires that `nums[left] >= nums[i]` must hold before the last swap**. Suppose we first "search from left to right", then if we cannot find an element larger than the pivot, **we will exit the loop when `i == j`, at which point it may be that `nums[j] == nums[i] > nums[left]`**. In other words, the last swap operation will swap an element larger than the pivot to the leftmost end of the array, causing sentinel partitioning to fail.
-For example, given the array `[0, 0, 0, 0, 1]`, if we first "search from left to right", the array after the sentinel partition is `[1, 0, 0, 0, 0]`, which is incorrect.
+For example, given the array `[0, 0, 0, 0, 1]`, if we first "search from left to right", the array after sentinel partitioning is `[1, 0, 0, 0, 0]`, which is incorrect.
-Upon further consideration, if we choose `nums[right]` as the pivot, then exactly the opposite, we must first "search from left to right".
+Thinking deeper, if we select `nums[right]` as the pivot, then it's exactly the opposite - we must first "search from left to right".
-**Q**: Regarding tail recursion optimization, why does choosing the shorter array ensure that the recursion depth does not exceed $\log n$?
+**Q**: Regarding the optimization of recursion depth in quick sort, why can selecting the shorter array ensure that the recursion depth does not exceed $\log n$?
-The recursion depth is the number of currently unreturned recursive methods. Each round of sentinel partition divides the original array into two subarrays. With tail recursion optimization, the length of the subarray to be recursively followed is at most half of the original array length. Assuming the worst case always halves the length, the final recursion depth will be $\log n$.
+The recursion depth is the number of currently unreturned recursive methods. Each round of sentinel partitioning divides the original array into two sub-arrays. After recursion depth optimization, the length of the sub-array to be recursively processed is at most half of the original array length. Assuming the worst case is always half the length, the final recursion depth will be $\log n$.
-Reviewing the original quicksort, we might continuously recursively process larger arrays, in the worst case from $n$, $n - 1$, ..., $2$, $1$, with a recursion depth of $n$. Tail recursion optimization can avoid this scenario.
+Reviewing the original quick sort, we may continuously recurse on the longer array. In the worst case, it would be $n$, $n - 1$, $\dots$, $2$, $1$, with a recursion depth of $n$. Recursion depth optimization can avoid this situation.
-**Q**: When all elements in the array are equal, is the time complexity of quicksort $O(n^2)$? How should this degenerate case be handled?
+**Q**: When all elements in the array are equal, is the time complexity of quick sort $O(n^2)$? How should this degenerate case be handled?
-Yes. For this situation, consider using sentinel partitioning to divide the array into three parts: less than, equal to, and greater than the pivot. Only recursively proceed with the less than and greater than parts. In this method, an array where all input elements are equal can be sorted in just one round of sentinel partitioning.
+Yes. For this situation, consider partitioning the array into three parts through sentinel partitioning: less than, equal to, and greater than the pivot. Only recursively process the less than and greater than parts. Under this method, an array where all input elements are equal can complete sorting in just one round of sentinel partitioning.
**Q**: Why is the worst-case time complexity of bucket sort $O(n^2)$?
-In the worst case, all elements are placed in the same bucket. If we use an $O(n^2)$ algorithm to sort these elements, the time complexity will be $O(n^2)$.
+In the worst case, all elements are distributed into the same bucket. If we use an $O(n^2)$ algorithm to sort these elements, the time complexity will be $O(n^2)$.
diff --git a/en/docs/chapter_stack_and_queue/deque.md b/en/docs/chapter_stack_and_queue/deque.md
index b0d0e0ca7..3a87e195d 100644
--- a/en/docs/chapter_stack_and_queue/deque.md
+++ b/en/docs/chapter_stack_and_queue/deque.md
@@ -1,320 +1,320 @@
-# Double-ended queue
+# Deque
-In a queue, we can only delete elements from the head or add elements to the tail. As shown in the figure below, a double-ended queue (deque) offers more flexibility, allowing the addition or removal of elements at both the head and the tail.
+In a queue, we can only remove elements from the front or add elements at the rear. As shown in the figure below, a double-ended queue (deque) provides greater flexibility, allowing the addition or removal of elements at both the front and rear.
-
+
-## Common operations in double-ended queue
+## Common Deque Operations
-The common operations in a double-ended queue are listed below, and the names of specific methods depend on the programming language used.
+The common operations on a deque are shown in the table below. The specific method names depend on the programming language used.
- Table Efficiency of double-ended queue operations
+ Table Efficiency of Deque Operations
-| Method Name | Description | Time Complexity |
-| ------------- | -------------------------- | --------------- |
-| `pushFirst()` | Add an element to the head | $O(1)$ |
-| `pushLast()` | Add an element to the tail | $O(1)$ |
-| `popFirst()` | Remove the first element | $O(1)$ |
-| `popLast()` | Remove the last element | $O(1)$ |
-| `peekFirst()` | Access the first element | $O(1)$ |
-| `peekLast()` | Access the last element | $O(1)$ |
+| Method | Description | Time Complexity |
+| -------------- | ------------------------- | --------------- |
+| `push_first()` | Add element to front | $O(1)$ |
+| `push_last()` | Add element to rear | $O(1)$ |
+| `pop_first()` | Remove front element | $O(1)$ |
+| `pop_last()` | Remove rear element | $O(1)$ |
+| `peek_first()` | Access front element | $O(1)$ |
+| `peek_last()` | Access rear element | $O(1)$ |
-Similarly, we can directly use the double-ended queue classes implemented in programming languages:
+Similarly, we can directly use the deque classes already implemented in programming languages:
=== "Python"
```python title="deque.py"
from collections import deque
- # Initialize the deque
+ # Initialize deque
deq: deque[int] = deque()
# Enqueue elements
- deq.append(2) # Add to the tail
+ deq.append(2) # Add to rear
deq.append(5)
deq.append(4)
- deq.appendleft(3) # Add to the head
+ deq.appendleft(3) # Add to front
deq.appendleft(1)
# Access elements
- front: int = deq[0] # The first element
- rear: int = deq[-1] # The last element
+ front: int = deq[0] # Front element
+ rear: int = deq[-1] # Rear element
# Dequeue elements
- pop_front: int = deq.popleft() # The first element dequeued
- pop_rear: int = deq.pop() # The last element dequeued
+ pop_front: int = deq.popleft() # Front element dequeue
+ pop_rear: int = deq.pop() # Rear element dequeue
- # Get the length of the deque
+ # Get deque length
size: int = len(deq)
- # Check if the deque is empty
+ # Check if deque is empty
is_empty: bool = len(deq) == 0
```
=== "C++"
```cpp title="deque.cpp"
- /* Initialize the deque */
+ /* Initialize deque */
deque deque;
/* Enqueue elements */
- deque.push_back(2); // Add to the tail
+ deque.push_back(2); // Add to rear
deque.push_back(5);
deque.push_back(4);
- deque.push_front(3); // Add to the head
+ deque.push_front(3); // Add to front
deque.push_front(1);
/* Access elements */
- int front = deque.front(); // The first element
- int back = deque.back(); // The last element
+ int front = deque.front(); // Front element
+ int back = deque.back(); // Rear element
/* Dequeue elements */
- deque.pop_front(); // The first element dequeued
- deque.pop_back(); // The last element dequeued
+ deque.pop_front(); // Front element dequeue
+ deque.pop_back(); // Rear element dequeue
- /* Get the length of the deque */
+ /* Get deque length */
int size = deque.size();
- /* Check if the deque is empty */
+ /* Check if deque is empty */
bool empty = deque.empty();
```
=== "Java"
```java title="deque.java"
- /* Initialize the deque */
+ /* Initialize deque */
Deque deque = new LinkedList<>();
/* Enqueue elements */
- deque.offerLast(2); // Add to the tail
+ deque.offerLast(2); // Add to rear
deque.offerLast(5);
deque.offerLast(4);
- deque.offerFirst(3); // Add to the head
+ deque.offerFirst(3); // Add to front
deque.offerFirst(1);
/* Access elements */
- int peekFirst = deque.peekFirst(); // The first element
- int peekLast = deque.peekLast(); // The last element
+ int peekFirst = deque.peekFirst(); // Front element
+ int peekLast = deque.peekLast(); // Rear element
/* Dequeue elements */
- int popFirst = deque.pollFirst(); // The first element dequeued
- int popLast = deque.pollLast(); // The last element dequeued
+ int popFirst = deque.pollFirst(); // Front element dequeue
+ int popLast = deque.pollLast(); // Rear element dequeue
- /* Get the length of the deque */
+ /* Get deque length */
int size = deque.size();
- /* Check if the deque is empty */
+ /* Check if deque is empty */
boolean isEmpty = deque.isEmpty();
```
=== "C#"
```csharp title="deque.cs"
- /* Initialize the deque */
- // In C#, LinkedList is used as a deque
+ /* Initialize deque */
+ // In C#, use LinkedList as a deque
LinkedList deque = new();
/* Enqueue elements */
- deque.AddLast(2); // Add to the tail
+ deque.AddLast(2); // Add to rear
deque.AddLast(5);
deque.AddLast(4);
- deque.AddFirst(3); // Add to the head
+ deque.AddFirst(3); // Add to front
deque.AddFirst(1);
/* Access elements */
- int peekFirst = deque.First.Value; // The first element
- int peekLast = deque.Last.Value; // The last element
+ int peekFirst = deque.First.Value; // Front element
+ int peekLast = deque.Last.Value; // Rear element
/* Dequeue elements */
- deque.RemoveFirst(); // The first element dequeued
- deque.RemoveLast(); // The last element dequeued
+ deque.RemoveFirst(); // Front element dequeue
+ deque.RemoveLast(); // Rear element dequeue
- /* Get the length of the deque */
+ /* Get deque length */
int size = deque.Count;
- /* Check if the deque is empty */
+ /* Check if deque is empty */
bool isEmpty = deque.Count == 0;
```
=== "Go"
```go title="deque_test.go"
- /* Initialize the deque */
+ /* Initialize deque */
// In Go, use list as a deque
deque := list.New()
/* Enqueue elements */
- deque.PushBack(2) // Add to the tail
+ deque.PushBack(2) // Add to rear
deque.PushBack(5)
deque.PushBack(4)
- deque.PushFront(3) // Add to the head
+ deque.PushFront(3) // Add to front
deque.PushFront(1)
/* Access elements */
- front := deque.Front() // The first element
- rear := deque.Back() // The last element
+ front := deque.Front() // Front element
+ rear := deque.Back() // Rear element
/* Dequeue elements */
- deque.Remove(front) // The first element dequeued
- deque.Remove(rear) // The last element dequeued
+ deque.Remove(front) // Front element dequeue
+ deque.Remove(rear) // Rear element dequeue
- /* Get the length of the deque */
+ /* Get deque length */
size := deque.Len()
- /* Check if the deque is empty */
+ /* Check if deque is empty */
isEmpty := deque.Len() == 0
```
=== "Swift"
```swift title="deque.swift"
- /* Initialize the deque */
- // Swift does not have a built-in deque class, so Array can be used as a deque
+ /* Initialize deque */
+ // Swift does not have a built-in deque class, can use Array as a deque
var deque: [Int] = []
/* Enqueue elements */
- deque.append(2) // Add to the tail
+ deque.append(2) // Add to rear
deque.append(5)
deque.append(4)
- deque.insert(3, at: 0) // Add to the head
+ deque.insert(3, at: 0) // Add to front
deque.insert(1, at: 0)
/* Access elements */
- let peekFirst = deque.first! // The first element
- let peekLast = deque.last! // The last element
+ let peekFirst = deque.first! // Front element
+ let peekLast = deque.last! // Rear element
/* Dequeue elements */
- // Using Array, popFirst has a complexity of O(n)
- let popFirst = deque.removeFirst() // The first element dequeued
- let popLast = deque.removeLast() // The last element dequeued
+ // When using Array simulation, popFirst has O(n) complexity
+ let popFirst = deque.removeFirst() // Front element dequeue
+ let popLast = deque.removeLast() // Rear element dequeue
- /* Get the length of the deque */
+ /* Get deque length */
let size = deque.count
- /* Check if the deque is empty */
+ /* Check if deque is empty */
let isEmpty = deque.isEmpty
```
=== "JS"
```javascript title="deque.js"
- /* Initialize the deque */
- // JavaScript does not have a built-in deque, so Array is used as a deque
+ /* Initialize deque */
+ // JavaScript does not have a built-in deque, can only use Array as a deque
const deque = [];
/* Enqueue elements */
deque.push(2);
deque.push(5);
deque.push(4);
- // Note that unshift() has a time complexity of O(n) as it's an array
+ // Please note that since it's an array, unshift() has O(n) time complexity
deque.unshift(3);
deque.unshift(1);
/* Access elements */
- const peekFirst = deque[0]; // The first element
- const peekLast = deque[deque.length - 1]; // The last element
+ const peekFirst = deque[0];
+ const peekLast = deque[deque.length - 1];
/* Dequeue elements */
- // Note that shift() has a time complexity of O(n) as it's an array
- const popFront = deque.shift(); // The first element dequeued
- const popBack = deque.pop(); // The last element dequeued
+ // Please note that since it's an array, shift() has O(n) time complexity
+ const popFront = deque.shift();
+ const popBack = deque.pop();
- /* Get the length of the deque */
+ /* Get deque length */
const size = deque.length;
- /* Check if the deque is empty */
+ /* Check if deque is empty */
const isEmpty = size === 0;
```
=== "TS"
```typescript title="deque.ts"
- /* Initialize the deque */
- // TypeScript does not have a built-in deque, so Array is used as a deque
+ /* Initialize deque */
+ // TypeScript does not have a built-in deque, can only use Array as a deque
const deque: number[] = [];
/* Enqueue elements */
deque.push(2);
deque.push(5);
deque.push(4);
- // Note that unshift() has a time complexity of O(n) as it's an array
+ // Please note that since it's an array, unshift() has O(n) time complexity
deque.unshift(3);
deque.unshift(1);
/* Access elements */
- const peekFirst: number = deque[0]; // The first element
- const peekLast: number = deque[deque.length - 1]; // The last element
+ const peekFirst: number = deque[0];
+ const peekLast: number = deque[deque.length - 1];
/* Dequeue elements */
- // Note that shift() has a time complexity of O(n) as it's an array
- const popFront: number = deque.shift() as number; // The first element dequeued
- const popBack: number = deque.pop() as number; // The last element dequeued
+ // Please note that since it's an array, shift() has O(n) time complexity
+ const popFront: number = deque.shift() as number;
+ const popBack: number = deque.pop() as number;
- /* Get the length of the deque */
+ /* Get deque length */
const size: number = deque.length;
- /* Check if the deque is empty */
+ /* Check if deque is empty */
const isEmpty: boolean = size === 0;
```
=== "Dart"
```dart title="deque.dart"
- /* Initialize the deque */
+ /* Initialize deque */
// In Dart, Queue is defined as a deque
Queue deque = Queue();
/* Enqueue elements */
- deque.addLast(2); // Add to the tail
+ deque.addLast(2); // Add to rear
deque.addLast(5);
deque.addLast(4);
- deque.addFirst(3); // Add to the head
+ deque.addFirst(3); // Add to front
deque.addFirst(1);
/* Access elements */
- int peekFirst = deque.first; // The first element
- int peekLast = deque.last; // The last element
+ int peekFirst = deque.first; // Front element
+ int peekLast = deque.last; // Rear element
/* Dequeue elements */
- int popFirst = deque.removeFirst(); // The first element dequeued
- int popLast = deque.removeLast(); // The last element dequeued
+ int popFirst = deque.removeFirst(); // Front element dequeue
+ int popLast = deque.removeLast(); // Rear element dequeue
- /* Get the length of the deque */
+ /* Get deque length */
int size = deque.length;
- /* Check if the deque is empty */
+ /* Check if deque is empty */
bool isEmpty = deque.isEmpty;
```
=== "Rust"
```rust title="deque.rs"
- /* Initialize the deque */
+ /* Initialize deque */
let mut deque: VecDeque = VecDeque::new();
/* Enqueue elements */
- deque.push_back(2); // Add to the tail
+ deque.push_back(2); // Add to rear
deque.push_back(5);
deque.push_back(4);
- deque.push_front(3); // Add to the head
+ deque.push_front(3); // Add to front
deque.push_front(1);
/* Access elements */
- if let Some(front) = deque.front() { // The first element
+ if let Some(front) = deque.front() { // Front element
}
- if let Some(rear) = deque.back() { // The last element
+ if let Some(rear) = deque.back() { // Rear element
}
/* Dequeue elements */
- if let Some(pop_front) = deque.pop_front() { // The first element dequeued
+ if let Some(pop_front) = deque.pop_front() { // Front element dequeue
}
- if let Some(pop_rear) = deque.pop_back() { // The last element dequeued
+ if let Some(pop_rear) = deque.pop_back() { // Rear element dequeue
}
- /* Get the length of the deque */
+ /* Get deque length */
let size = deque.len();
- /* Check if the deque is empty */
+ /* Check if deque is empty */
let is_empty = deque.is_empty();
```
@@ -327,7 +327,60 @@ Similarly, we can directly use the double-ended queue classes implemented in pro
=== "Kotlin"
```kotlin title="deque.kt"
+ /* Initialize deque */
+ val deque = LinkedList()
+ /* Enqueue elements */
+ deque.offerLast(2) // Add to rear
+ deque.offerLast(5)
+ deque.offerLast(4)
+ deque.offerFirst(3) // Add to front
+ deque.offerFirst(1)
+
+ /* Access elements */
+ val peekFirst = deque.peekFirst() // Front element
+ val peekLast = deque.peekLast() // Rear element
+
+ /* Dequeue elements */
+ val popFirst = deque.pollFirst() // Front element dequeue
+ val popLast = deque.pollLast() // Rear element dequeue
+
+ /* Get deque length */
+ val size = deque.size
+
+ /* Check if deque is empty */
+ val isEmpty = deque.isEmpty()
+ ```
+
+=== "Ruby"
+
+ ```ruby title="deque.rb"
+ # Initialize deque
+ # Ruby does not have a built-in deque, can only use Array as a deque
+ deque = []
+
+ # Enqueue elements
+ deque << 2
+ deque << 5
+ deque << 4
+ # Please note that since it's an array, Array#unshift has O(n) time complexity
+ deque.unshift(3)
+ deque.unshift(1)
+
+ # Access elements
+ peek_first = deque.first
+ peek_last = deque.last
+
+ # Dequeue elements
+ # Please note that since it's an array, Array#shift has O(n) time complexity
+ pop_front = deque.shift
+ pop_back = deque.pop
+
+ # Get deque length
+ size = deque.length
+
+ # Check if deque is empty
+ is_empty = size.zero?
```
=== "Zig"
@@ -336,70 +389,70 @@ Similarly, we can directly use the double-ended queue classes implemented in pro
```
-??? pythontutor "Visualizing Code"
+??? pythontutor "Visualize Execution"
https://pythontutor.com/render.html#code=from%20collections%20import%20deque%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%0A%20%20%20%20deq%20%3D%20deque%28%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E9%98%9F%0A%20%20%20%20deq.append%282%29%20%20%23%20%E6%B7%BB%E5%8A%A0%E8%87%B3%E9%98%9F%E5%B0%BE%0A%20%20%20%20deq.append%285%29%0A%20%20%20%20deq.append%284%29%0A%20%20%20%20deq.appendleft%283%29%20%20%23%20%E6%B7%BB%E5%8A%A0%E8%87%B3%E9%98%9F%E9%A6%96%0A%20%20%20%20deq.appendleft%281%29%0A%20%20%20%20print%28%22%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%20deque%20%3D%22,%20deq%29%0A%0A%20%20%20%20%23%20%E8%AE%BF%E9%97%AE%E5%85%83%E7%B4%A0%0A%20%20%20%20front%20%3D%20deq%5B0%5D%20%20%23%20%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%20front%20%3D%22,%20front%29%0A%20%20%20%20rear%20%3D%20deq%5B-1%5D%20%20%23%20%E9%98%9F%E5%B0%BE%E5%85%83%E7%B4%A0%0A%20%20%20%20print%28%22%E9%98%9F%E5%B0%BE%E5%85%83%E7%B4%A0%20rear%20%3D%22,%20rear%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20pop_front%20%3D%20deq.popleft%28%29%20%20%23%20%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%87%BA%E9%98%9F%E5%85%83%E7%B4%A0%20%20pop_front%20%3D%22,%20pop_front%29%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%87%BA%E9%98%9F%E5%90%8E%20deque%20%3D%22,%20deq%29%0A%20%20%20%20pop_rear%20%3D%20deq.pop%28%29%20%20%23%20%E9%98%9F%E5%B0%BE%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20print%28%22%E9%98%9F%E5%B0%BE%E5%87%BA%E9%98%9F%E5%85%83%E7%B4%A0%20%20pop_rear%20%3D%22,%20pop_rear%29%0A%20%20%20%20print%28%22%E9%98%9F%E5%B0%BE%E5%87%BA%E9%98%9F%E5%90%8E%20deque%20%3D%22,%20deq%29%0A%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E7%9A%84%E9%95%BF%E5%BA%A6%0A%20%20%20%20size%20%3D%20len%28deq%29%0A%20%20%20%20print%28%22%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E9%95%BF%E5%BA%A6%20size%20%3D%22,%20size%29%0A%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20len%28deq%29%20%3D%3D%200%0A%20%20%20%20print%28%22%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%20%3D%22,%20is_empty%29&cumulative=false&curInstr=3&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false
-## Implementing a double-ended queue *
+## Deque Implementation *
-The implementation of a double-ended queue is similar to that of a regular queue, it can be based on either a linked list or an array as the underlying data structure.
+The implementation of a deque is similar to that of a queue. You can choose either a linked list or an array as the underlying data structure.
-### Implementation based on doubly linked list
+### Doubly Linked List Implementation
-Recall from the previous section that we used a regular singly linked list to implement a queue, as it conveniently allows for deleting from the head (corresponding to the dequeue operation) and adding new elements after the tail (corresponding to the enqueue operation).
+Reviewing the previous section, we used a regular singly linked list to implement a queue because it conveniently allows deleting the head node (corresponding to dequeue) and adding new nodes after the tail node (corresponding to enqueue).
-For a double-ended queue, both the head and the tail can perform enqueue and dequeue operations. In other words, a double-ended queue needs to implement operations in the opposite direction as well. For this, we use a "doubly linked list" as the underlying data structure of the double-ended queue.
+For a deque, both the front and rear can perform enqueue and dequeue operations. In other words, a deque needs to implement operations in the opposite direction as well. For this reason, we use a "doubly linked list" as the underlying data structure for the deque.
-As shown in the figure below, we treat the head and tail nodes of the doubly linked list as the front and rear of the double-ended queue, respectively, and implement the functionality to add and remove nodes at both ends.
+As shown in the figure below, we treat the head and tail nodes of the doubly linked list as the front and rear of the deque, implementing functionality to add and remove nodes at both ends.
=== "LinkedListDeque"
- 
+ 
-=== "pushLast()"
+=== "push_last()"
-=== "pushFirst()"
+=== "push_first()"
-=== "popLast()"
+=== "pop_last()"
-=== "popFirst()"
+=== "pop_first()"
-The implementation code is as follows:
+The implementation code is shown below:
```src
[file]{linkedlist_deque}-[class]{linked_list_deque}-[func]{}
```
-### Implementation based on array
+### Array Implementation
-As shown in the figure below, similar to implementing a queue with an array, we can also use a circular array to implement a double-ended queue.
+As shown in the figure below, similar to implementing a queue based on an array, we can also use a circular array to implement a deque.
=== "ArrayDeque"
- 
+ 
-=== "pushLast()"
+=== "push_last()"
-=== "pushFirst()"
+=== "push_first()"
-=== "popLast()"
+=== "pop_last()"
-=== "popFirst()"
+=== "pop_first()"
-The implementation only needs to add methods for "front enqueue" and "rear dequeue":
+Based on the queue implementation, we only need to add methods for "enqueue at front" and "dequeue from rear":
```src
[file]{array_deque}-[class]{array_deque}-[func]{}
```
-## Applications of double-ended queue
+## Deque Applications
-The double-ended queue combines the logic of both stacks and queues, **thus, it can implement all their respective use cases while offering greater flexibility**.
+A deque combines the logic of both stacks and queues. **Therefore, it can implement all application scenarios of both, while providing greater flexibility**.
-We know that software's "undo" feature is typically implemented using a stack: the system `pushes` each change operation onto the stack and then `pops` to implement undoing. However, considering the limitations of system resources, software often restricts the number of undo steps (for example, only allowing the last 50 steps). When the stack length exceeds 50, the software needs to perform a deletion operation at the bottom of the stack (the front of the queue). **But a regular stack cannot perform this function, where a double-ended queue becomes necessary**. Note that the core logic of "undo" still follows the Last-In-First-Out principle of a stack, but a double-ended queue can more flexibly implement some additional logic.
+We know that the "undo" function in software is typically implemented using a stack: the system pushes each change operation onto the stack and then implements undo through pop. However, considering system resource limitations, software usually limits the number of undo steps (for example, only allowing 50 steps to be saved). When the stack length exceeds 50, the software needs to perform a deletion operation at the bottom of the stack (front of the queue). **But a stack cannot implement this functionality, so a deque is needed to replace the stack**. Note that the core logic of "undo" still follows the LIFO principle of a stack; it's just that the deque can more flexibly implement some additional logic.
diff --git a/en/docs/chapter_stack_and_queue/index.md b/en/docs/chapter_stack_and_queue/index.md
index 7d2d4ff55..461d82a27 100644
--- a/en/docs/chapter_stack_and_queue/index.md
+++ b/en/docs/chapter_stack_and_queue/index.md
@@ -1,9 +1,9 @@
-# Stack and queue
+# Stack and Queue
-
+
!!! abstract
- A stack is like cats placed on top of each other, while a queue is like cats lined up one by one.
-
- They represent the logical relationships of Last-In-First-Out (LIFO) and First-In-First-Out (FIFO), respectively.
+ Stacks are like stacking cats, while queues are like cats lining up.
+
+ They represent LIFO (Last In First Out) and FIFO (First In First Out) logic, respectively.
diff --git a/en/docs/chapter_stack_and_queue/queue.md b/en/docs/chapter_stack_and_queue/queue.md
index 186f932d7..8f43c8d9b 100755
--- a/en/docs/chapter_stack_and_queue/queue.md
+++ b/en/docs/chapter_stack_and_queue/queue.md
@@ -1,22 +1,22 @@
# Queue
-A queue is a linear data structure that follows the First-In-First-Out (FIFO) rule. As the name suggests, a queue simulates the phenomenon of lining up, where newcomers join the queue at the rear, and the person at the front leaves the queue first.
+A queue is a linear data structure that follows the First In First Out (FIFO) rule. As the name suggests, a queue simulates the phenomenon of lining up, where newcomers continuously join the end of the queue, while people at the front of the queue leave one by one.
-As shown in the figure below, we call the front of the queue the "head" and the back the "tail." The operation of adding elements to the rear of the queue is termed "enqueue," and the operation of removing elements from the front is termed "dequeue."
+As shown in the figure below, we call the front of the queue the "front" and the end the "rear." The operation of adding an element to the rear is called "enqueue," and the operation of removing the front element is called "dequeue."
-
+
-## Common operations on queue
+## Common Queue Operations
-The common operations on a queue are shown in the table below. Note that method names may vary across different programming languages. Here, we use the same naming convention as that used for stacks.
+The common operations on a queue are shown in the table below. Note that method names may vary across different programming languages. We adopt the same naming convention as for stacks here.
- Table Efficiency of queue operations
+ Table Efficiency of Queue Operations
-| Method Name | Description | Time Complexity |
-| ----------- | -------------------------------------- | --------------- |
-| `push()` | Enqueue an element, add it to the tail | $O(1)$ |
-| `pop()` | Dequeue the head element | $O(1)$ |
-| `peek()` | Access the head element | $O(1)$ |
+| Method | Description | Time Complexity |
+| -------- | ------------------------------------------ | --------------- |
+| `push()` | Enqueue element, add element to rear | $O(1)$ |
+| `pop()` | Dequeue front element | $O(1)$ |
+| `peek()` | Access front element | $O(1)$ |
We can directly use the ready-made queue classes in programming languages:
@@ -25,9 +25,9 @@ We can directly use the ready-made queue classes in programming languages:
```python title="queue.py"
from collections import deque
- # Initialize the queue
+ # Initialize queue
# In Python, we generally use the deque class as a queue
- # Although queue.Queue() is a pure queue class, it's not very user-friendly, so it's not recommended
+ # Although queue.Queue() is a pure queue class, it is not very user-friendly, so it is not recommended
que: deque[int] = deque()
# Enqueue elements
@@ -37,23 +37,23 @@ We can directly use the ready-made queue classes in programming languages:
que.append(5)
que.append(4)
- # Access the first element
+ # Access front element
front: int = que[0]
- # Dequeue an element
+ # Dequeue element
pop: int = que.popleft()
- # Get the length of the queue
+ # Get queue length
size: int = len(que)
- # Check if the queue is empty
+ # Check if queue is empty
is_empty: bool = len(que) == 0
```
=== "C++"
```cpp title="queue.cpp"
- /* Initialize the queue */
+ /* Initialize queue */
queue queue;
/* Enqueue elements */
@@ -63,23 +63,23 @@ We can directly use the ready-made queue classes in programming languages:
queue.push(5);
queue.push(4);
- /* Access the first element*/
+ /* Access front element */
int front = queue.front();
- /* Dequeue an element */
+ /* Dequeue element */
queue.pop();
- /* Get the length of the queue */
+ /* Get queue length */
int size = queue.size();
- /* Check if the queue is empty */
+ /* Check if queue is empty */
bool empty = queue.empty();
```
=== "Java"
```java title="queue.java"
- /* Initialize the queue */
+ /* Initialize queue */
Queue queue = new LinkedList<>();
/* Enqueue elements */
@@ -89,23 +89,23 @@ We can directly use the ready-made queue classes in programming languages:
queue.offer(5);
queue.offer(4);
- /* Access the first element */
+ /* Access front element */
int peek = queue.peek();
- /* Dequeue an element */
+ /* Dequeue element */
int pop = queue.poll();
- /* Get the length of the queue */
+ /* Get queue length */
int size = queue.size();
- /* Check if the queue is empty */
+ /* Check if queue is empty */
boolean isEmpty = queue.isEmpty();
```
=== "C#"
```csharp title="queue.cs"
- /* Initialize the queue */
+ /* Initialize queue */
Queue queue = new();
/* Enqueue elements */
@@ -115,23 +115,23 @@ We can directly use the ready-made queue classes in programming languages:
queue.Enqueue(5);
queue.Enqueue(4);
- /* Access the first element */
+ /* Access front element */
int peek = queue.Peek();
- /* Dequeue an element */
+ /* Dequeue element */
int pop = queue.Dequeue();
- /* Get the length of the queue */
+ /* Get queue length */
int size = queue.Count;
- /* Check if the queue is empty */
+ /* Check if queue is empty */
bool isEmpty = queue.Count == 0;
```
=== "Go"
```go title="queue_test.go"
- /* Initialize the queue */
+ /* Initialize queue */
// In Go, use list as a queue
queue := list.New()
@@ -142,25 +142,25 @@ We can directly use the ready-made queue classes in programming languages:
queue.PushBack(5)
queue.PushBack(4)
- /* Access the first element */
+ /* Access front element */
peek := queue.Front()
- /* Dequeue an element */
+ /* Dequeue element */
pop := queue.Front()
queue.Remove(pop)
- /* Get the length of the queue */
+ /* Get queue length */
size := queue.Len()
- /* Check if the queue is empty */
+ /* Check if queue is empty */
isEmpty := queue.Len() == 0
```
=== "Swift"
```swift title="queue.swift"
- /* Initialize the queue */
- // Swift does not have a built-in queue class, so Array can be used as a queue
+ /* Initialize queue */
+ // Swift does not have a built-in queue class, can use Array as a queue
var queue: [Int] = []
/* Enqueue elements */
@@ -170,25 +170,25 @@ We can directly use the ready-made queue classes in programming languages:
queue.append(5)
queue.append(4)
- /* Access the first element */
+ /* Access front element */
let peek = queue.first!
- /* Dequeue an element */
- // Since it's an array, removeFirst has a complexity of O(n)
+ /* Dequeue element */
+ // Since it's an array, removeFirst has O(n) complexity
let pool = queue.removeFirst()
- /* Get the length of the queue */
+ /* Get queue length */
let size = queue.count
- /* Check if the queue is empty */
+ /* Check if queue is empty */
let isEmpty = queue.isEmpty
```
=== "JS"
```javascript title="queue.js"
- /* Initialize the queue */
- // JavaScript does not have a built-in queue, so Array can be used as a queue
+ /* Initialize queue */
+ // JavaScript does not have a built-in queue, can use Array as a queue
const queue = [];
/* Enqueue elements */
@@ -198,25 +198,25 @@ We can directly use the ready-made queue classes in programming languages:
queue.push(5);
queue.push(4);
- /* Access the first element */
+ /* Access front element */
const peek = queue[0];
- /* Dequeue an element */
- // Since the underlying structure is an array, shift() method has a time complexity of O(n)
+ /* Dequeue element */
+ // The underlying structure is an array, so shift() has O(n) time complexity
const pop = queue.shift();
- /* Get the length of the queue */
+ /* Get queue length */
const size = queue.length;
- /* Check if the queue is empty */
+ /* Check if queue is empty */
const empty = queue.length === 0;
```
=== "TS"
```typescript title="queue.ts"
- /* Initialize the queue */
- // TypeScript does not have a built-in queue, so Array can be used as a queue
+ /* Initialize queue */
+ // TypeScript does not have a built-in queue, can use Array as a queue
const queue: number[] = [];
/* Enqueue elements */
@@ -226,25 +226,25 @@ We can directly use the ready-made queue classes in programming languages:
queue.push(5);
queue.push(4);
- /* Access the first element */
+ /* Access front element */
const peek = queue[0];
- /* Dequeue an element */
- // Since the underlying structure is an array, shift() method has a time complexity of O(n)
+ /* Dequeue element */
+ // The underlying structure is an array, so shift() has O(n) time complexity
const pop = queue.shift();
- /* Get the length of the queue */
+ /* Get queue length */
const size = queue.length;
- /* Check if the queue is empty */
+ /* Check if queue is empty */
const empty = queue.length === 0;
```
=== "Dart"
```dart title="queue.dart"
- /* Initialize the queue */
- // In Dart, the Queue class is a double-ended queue but can be used as a queue
+ /* Initialize queue */
+ // In Dart, the Queue class is a deque and can also be used as a queue
Queue queue = Queue();
/* Enqueue elements */
@@ -254,24 +254,24 @@ We can directly use the ready-made queue classes in programming languages:
queue.add(5);
queue.add(4);
- /* Access the first element */
+ /* Access front element */
int peek = queue.first;
- /* Dequeue an element */
+ /* Dequeue element */
int pop = queue.removeFirst();
- /* Get the length of the queue */
+ /* Get queue length */
int size = queue.length;
- /* Check if the queue is empty */
+ /* Check if queue is empty */
bool isEmpty = queue.isEmpty;
```
=== "Rust"
```rust title="queue.rs"
- /* Initialize the double-ended queue */
- // In Rust, use a double-ended queue as a regular queue
+ /* Initialize deque */
+ // In Rust, use deque as a regular queue
let mut deque: VecDeque = VecDeque::new();
/* Enqueue elements */
@@ -281,18 +281,18 @@ We can directly use the ready-made queue classes in programming languages:
deque.push_back(5);
deque.push_back(4);
- /* Access the first element */
+ /* Access front element */
if let Some(front) = deque.front() {
}
- /* Dequeue an element */
+ /* Dequeue element */
if let Some(pop) = deque.pop_front() {
}
- /* Get the length of the queue */
+ /* Get queue length */
let size = deque.len();
- /* Check if the queue is empty */
+ /* Check if queue is empty */
let is_empty = deque.is_empty();
```
@@ -305,7 +305,55 @@ We can directly use the ready-made queue classes in programming languages:
=== "Kotlin"
```kotlin title="queue.kt"
+ /* Initialize queue */
+ val queue = LinkedList()
+ /* Enqueue elements */
+ queue.offer(1)
+ queue.offer(3)
+ queue.offer(2)
+ queue.offer(5)
+ queue.offer(4)
+
+ /* Access front element */
+ val peek = queue.peek()
+
+ /* Dequeue element */
+ val pop = queue.poll()
+
+ /* Get queue length */
+ val size = queue.size
+
+ /* Check if queue is empty */
+ val isEmpty = queue.isEmpty()
+ ```
+
+=== "Ruby"
+
+ ```ruby title="queue.rb"
+ # Initialize queue
+ # Ruby's built-in queue (Thread::Queue) does not have peek and traversal methods, can use Array as a queue
+ queue = []
+
+ # Enqueue elements
+ queue.push(1)
+ queue.push(3)
+ queue.push(2)
+ queue.push(5)
+ queue.push(4)
+
+ # Access front element
+ peek = queue.first
+
+ # Dequeue element
+ # Please note that since it's an array, Array#shift has O(n) time complexity
+ pop = queue.shift
+
+ # Get queue length
+ size = queue.length
+
+ # Check if queue is empty
+ is_empty = queue.empty?
```
=== "Zig"
@@ -314,20 +362,20 @@ We can directly use the ready-made queue classes in programming languages:
```
-??? pythontutor "Code Visualization"
+??? pythontutor "Visualize Execution"
https://pythontutor.com/render.html#code=from%20collections%20import%20deque%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E9%98%9F%E5%88%97%0A%20%20%20%20%23%20%E5%9C%A8%20Python%20%E4%B8%AD%EF%BC%8C%E6%88%91%E4%BB%AC%E4%B8%80%E8%88%AC%E5%B0%86%E5%8F%8C%E5%90%91%E9%98%9F%E5%88%97%E7%B1%BB%20deque%20%E7%9C%8B%E4%BD%9C%E9%98%9F%E5%88%97%E4%BD%BF%E7%94%A8%0A%20%20%20%20%23%20%E8%99%BD%E7%84%B6%20queue.Queue%28%29%20%E6%98%AF%E7%BA%AF%E6%AD%A3%E7%9A%84%E9%98%9F%E5%88%97%E7%B1%BB%EF%BC%8C%E4%BD%86%E4%B8%8D%E5%A4%AA%E5%A5%BD%E7%94%A8%0A%20%20%20%20que%20%3D%20deque%28%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E9%98%9F%0A%20%20%20%20que.append%281%29%0A%20%20%20%20que.append%283%29%0A%20%20%20%20que.append%282%29%0A%20%20%20%20que.append%285%29%0A%20%20%20%20que.append%284%29%0A%20%20%20%20print%28%22%E9%98%9F%E5%88%97%20que%20%3D%22,%20que%29%0A%0A%20%20%20%20%23%20%E8%AE%BF%E9%97%AE%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%0A%20%20%20%20front%20%3D%20que%5B0%5D%0A%20%20%20%20print%28%22%E9%98%9F%E9%A6%96%E5%85%83%E7%B4%A0%20front%20%3D%22,%20front%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%87%BA%E9%98%9F%0A%20%20%20%20pop%20%3D%20que.popleft%28%29%0A%20%20%20%20print%28%22%E5%87%BA%E9%98%9F%E5%85%83%E7%B4%A0%20pop%20%3D%22,%20pop%29%0A%20%20%20%20print%28%22%E5%87%BA%E9%98%9F%E5%90%8E%20que%20%3D%22,%20que%29%0A%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E9%98%9F%E5%88%97%E7%9A%84%E9%95%BF%E5%BA%A6%0A%20%20%20%20size%20%3D%20len%28que%29%0A%20%20%20%20print%28%22%E9%98%9F%E5%88%97%E9%95%BF%E5%BA%A6%20size%20%3D%22,%20size%29%0A%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20len%28que%29%20%3D%3D%200%0A%20%20%20%20print%28%22%E9%98%9F%E5%88%97%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%20%3D%22,%20is_empty%29&cumulative=false&curInstr=3&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false
-## Implementing a queue
+## Queue Implementation
-To implement a queue, we need a data structure that allows adding elements at one end and removing them at the other. Both linked lists and arrays meet this requirement.
+To implement a queue, we need a data structure that allows adding elements at one end and removing elements at the other end. Both linked lists and arrays meet this requirement.
-### Implementation based on a linked list
+### Linked List Implementation
-As shown in the figure below, we can consider the "head node" and "tail node" of a linked list as the "front" and "rear" of the queue, respectively. It is stipulated that nodes can only be added at the rear and removed at the front.
+As shown in the figure below, we can treat the "head node" and "tail node" of a linked list as the "front" and "rear" of the queue, respectively, with the rule that nodes can only be added at the rear and removed from the front.
=== "LinkedListQueue"
- 
+ 
=== "push()"
@@ -341,21 +389,21 @@ Below is the code for implementing a queue using a linked list:
[file]{linkedlist_queue}-[class]{linked_list_queue}-[func]{}
```
-### Implementation based on an array
+### Array Implementation
-Deleting the first element in an array has a time complexity of $O(n)$, which would make the dequeue operation inefficient. However, this problem can be cleverly avoided as follows.
+Deleting the first element in an array has a time complexity of $O(n)$, which would make the dequeue operation inefficient. However, we can use the following clever method to avoid this problem.
-We use a variable `front` to indicate the index of the front element and maintain a variable `size` to record the queue's length. Define `rear = front + size`, which points to the position immediately following the tail element.
+We can use a variable `front` to point to the index of the front element and maintain a variable `size` to record the queue length. We define `rear = front + size`, which calculates the position right after the rear element.
-With this design, **the effective interval of elements in the array is `[front, rear - 1]`**. The implementation methods for various operations are shown in the figure below.
+Based on this design, **the valid interval containing elements in the array is `[front, rear - 1]`**. The implementation methods for various operations are shown in the figure below:
- Enqueue operation: Assign the input element to the `rear` index and increase `size` by 1.
- Dequeue operation: Simply increase `front` by 1 and decrease `size` by 1.
-Both enqueue and dequeue operations only require a single operation, each with a time complexity of $O(1)$.
+As you can see, both enqueue and dequeue operations require only one operation, with a time complexity of $O(1)$.
=== "ArrayQueue"
- 
+ 
=== "push()"
@@ -363,19 +411,19 @@ Both enqueue and dequeue operations only require a single operation, each with a
=== "pop()"
-You might notice a problem: as enqueue and dequeue operations are continuously performed, both `front` and `rear` move to the right and **will eventually reach the end of the array and can't move further**. To resolve this, we can treat the array as a "circular array" where connecting the end of the array back to its beginning.
+You may notice a problem: as we continuously enqueue and dequeue, both `front` and `rear` move to the right. **When they reach the end of the array, they cannot continue moving**. To solve this problem, we can treat the array as a "circular array" with head and tail connected.
-In a circular array, `front` or `rear` needs to loop back to the start of the array upon reaching the end. This cyclical pattern can be achieved with a "modulo operation" as shown in the code below:
+For a circular array, we need to let `front` or `rear` wrap around to the beginning of the array when they cross the end. This periodic pattern can be implemented using the "modulo operation," as shown in the code below:
```src
[file]{array_queue}-[class]{array_queue}-[func]{}
```
-The above implementation of the queue still has its limitations: its length is fixed. However, this issue is not difficult to resolve. We can replace the array with a dynamic array that can expand itself if needed. Interested readers can try to implement this themselves.
+The queue implemented above still has limitations: its length is immutable. However, this problem is not difficult to solve. We can replace the array with a dynamic array to introduce an expansion mechanism. Interested readers can try to implement this themselves.
-The comparison of the two implementations is consistent with that of the stack and is not repeated here.
+The comparison conclusions for the two implementations are consistent with those for stacks and will not be repeated here.
-## Typical applications of queue
+## Typical Applications of Queue
-- **Amazon orders**: After shoppers place orders, these orders join a queue, and the system processes them in order. During events like Singles' Day, a massive number of orders are generated in a short time, making high concurrency a key challenge for engineers.
-- **Various to-do lists**: Any scenario requiring a "first-come, first-served" functionality, such as a printer's task queue or a restaurant's food delivery queue, can effectively maintain the order of processing with a queue.
+- **Taobao orders**. After shoppers place orders, the orders are added to a queue, and the system subsequently processes the orders in the queue according to their sequence. During Double Eleven, massive orders are generated in a short time, and high concurrency becomes a key challenge that engineers need to tackle.
+- **Various to-do tasks**. Any scenario that needs to implement "first come, first served" functionality, such as a printer's task queue or a restaurant's order queue, can effectively maintain the processing order using queues.
diff --git a/en/docs/chapter_stack_and_queue/stack.md b/en/docs/chapter_stack_and_queue/stack.md
index 0548ec18e..32f8f90d6 100755
--- a/en/docs/chapter_stack_and_queue/stack.md
+++ b/en/docs/chapter_stack_and_queue/stack.md
@@ -1,292 +1,292 @@
# Stack
-A stack is a linear data structure that follows the principle of Last-In-First-Out (LIFO).
+A stack is a linear data structure that follows the Last In First Out (LIFO) logic.
-We can compare a stack to a pile of plates on a table. To access the bottom plate, one must first remove the plates on top. By replacing the plates with various types of elements (such as integers, characters, objects, etc.), we obtain the data structure known as a stack.
+We can compare a stack to a pile of plates on a table. If we specify that only one plate can be moved at a time, then to get the bottom plate, we must first remove the plates above it one by one. If we replace the plates with various types of elements (such as integers, characters, objects, etc.), we get the stack data structure.
-As shown in the figure below, we refer to the top of the pile of elements as the "top of the stack" and the bottom as the "bottom of the stack." The operation of adding elements to the top of the stack is called "push," and the operation of removing the top element is called "pop."
+As shown in the figure below, we call the top of the stacked elements the "top" and the bottom the "base." The operation of adding an element to the top is called "push," and the operation of removing the top element is called "pop."
-
+
-## Common operations on stack
+## Common Stack Operations
-The common operations on a stack are shown in the table below. The specific method names depend on the programming language used. Here, we use `push()`, `pop()`, and `peek()` as examples.
+The common operations on a stack are shown in the table below. The specific method names depend on the programming language used. Here, we use the common naming convention of `push()`, `pop()`, and `peek()`.
- Table Efficiency of stack operations
+ Table Efficiency of Stack Operations
-| Method | Description | Time Complexity |
-| -------- | ----------------------------------------------- | --------------- |
-| `push()` | Push an element onto the stack (add to the top) | $O(1)$ |
-| `pop()` | Pop the top element from the stack | $O(1)$ |
-| `peek()` | Access the top element of the stack | $O(1)$ |
+| Method | Description | Time Complexity |
+| -------- | ---------------------------------------------- | --------------- |
+| `push()` | Push element onto stack (add to top) | $O(1)$ |
+| `pop()` | Pop top element from stack | $O(1)$ |
+| `peek()` | Access top element | $O(1)$ |
-Typically, we can directly use the stack class built into the programming language. However, some languages may not specifically provide a stack class. In these cases, we can use the language's "array" or "linked list" as a stack and ignore operations that are not related to stack logic in the program.
+Typically, we can directly use the built-in stack class provided by the programming language. However, some languages may not provide a dedicated stack class. In these cases, we can use the language's "array" or "linked list" as a stack and ignore operations unrelated to the stack in the program logic.
=== "Python"
```python title="stack.py"
- # Initialize the stack
- # Python does not have a built-in stack class, so a list can be used as a stack
+ # Initialize stack
+ # Python does not have a built-in stack class, can use list as a stack
stack: list[int] = []
- # Push elements onto the stack
+ # Push elements
stack.append(1)
stack.append(3)
stack.append(2)
stack.append(5)
stack.append(4)
- # Access the top element of the stack
+ # Access top element
peek: int = stack[-1]
- # Pop an element from the stack
+ # Pop element
pop: int = stack.pop()
- # Get the length of the stack
+ # Get stack length
size: int = len(stack)
- # Check if the stack is empty
+ # Check if empty
is_empty: bool = len(stack) == 0
```
=== "C++"
```cpp title="stack.cpp"
- /* Initialize the stack */
+ /* Initialize stack */
stack stack;
- /* Push elements onto the stack */
+ /* Push elements */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
- /* Access the top element of the stack */
+ /* Access top element */
int top = stack.top();
- /* Pop an element from the stack */
+ /* Pop element */
stack.pop(); // No return value
- /* Get the length of the stack */
+ /* Get stack length */
int size = stack.size();
- /* Check if the stack is empty */
+ /* Check if empty */
bool empty = stack.empty();
```
=== "Java"
```java title="stack.java"
- /* Initialize the stack */
+ /* Initialize stack */
Stack stack = new Stack<>();
- /* Push elements onto the stack */
+ /* Push elements */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
- /* Access the top element of the stack */
+ /* Access top element */
int peek = stack.peek();
- /* Pop an element from the stack */
+ /* Pop element */
int pop = stack.pop();
- /* Get the length of the stack */
+ /* Get stack length */
int size = stack.size();
- /* Check if the stack is empty */
+ /* Check if empty */
boolean isEmpty = stack.isEmpty();
```
=== "C#"
```csharp title="stack.cs"
- /* Initialize the stack */
+ /* Initialize stack */
Stack stack = new();
- /* Push elements onto the stack */
+ /* Push elements */
stack.Push(1);
stack.Push(3);
stack.Push(2);
stack.Push(5);
stack.Push(4);
- /* Access the top element of the stack */
+ /* Access top element */
int peek = stack.Peek();
- /* Pop an element from the stack */
+ /* Pop element */
int pop = stack.Pop();
- /* Get the length of the stack */
+ /* Get stack length */
int size = stack.Count;
- /* Check if the stack is empty */
+ /* Check if empty */
bool isEmpty = stack.Count == 0;
```
=== "Go"
```go title="stack_test.go"
- /* Initialize the stack */
- // In Go, it is recommended to use a Slice as a stack
+ /* Initialize stack */
+ // In Go, it is recommended to use Slice as a stack
var stack []int
- /* Push elements onto the stack */
+ /* Push elements */
stack = append(stack, 1)
stack = append(stack, 3)
stack = append(stack, 2)
stack = append(stack, 5)
stack = append(stack, 4)
- /* Access the top element of the stack */
+ /* Access top element */
peek := stack[len(stack)-1]
- /* Pop an element from the stack */
+ /* Pop element */
pop := stack[len(stack)-1]
stack = stack[:len(stack)-1]
- /* Get the length of the stack */
+ /* Get stack length */
size := len(stack)
- /* Check if the stack is empty */
+ /* Check if empty */
isEmpty := len(stack) == 0
```
=== "Swift"
```swift title="stack.swift"
- /* Initialize the stack */
- // Swift does not have a built-in stack class, so Array can be used as a stack
+ /* Initialize stack */
+ // Swift does not have a built-in stack class, can use Array as a stack
var stack: [Int] = []
- /* Push elements onto the stack */
+ /* Push elements */
stack.append(1)
stack.append(3)
stack.append(2)
stack.append(5)
stack.append(4)
- /* Access the top element of the stack */
+ /* Access top element */
let peek = stack.last!
- /* Pop an element from the stack */
+ /* Pop element */
let pop = stack.removeLast()
- /* Get the length of the stack */
+ /* Get stack length */
let size = stack.count
- /* Check if the stack is empty */
+ /* Check if empty */
let isEmpty = stack.isEmpty
```
=== "JS"
```javascript title="stack.js"
- /* Initialize the stack */
- // JavaScript does not have a built-in stack class, so Array can be used as a stack
+ /* Initialize stack */
+ // JavaScript does not have a built-in stack class, can use Array as a stack
const stack = [];
- /* Push elements onto the stack */
+ /* Push elements */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
- /* Access the top element of the stack */
+ /* Access top element */
const peek = stack[stack.length-1];
- /* Pop an element from the stack */
+ /* Pop element */
const pop = stack.pop();
- /* Get the length of the stack */
+ /* Get stack length */
const size = stack.length;
- /* Check if the stack is empty */
+ /* Check if empty */
const is_empty = stack.length === 0;
```
=== "TS"
```typescript title="stack.ts"
- /* Initialize the stack */
- // TypeScript does not have a built-in stack class, so Array can be used as a stack
+ /* Initialize stack */
+ // TypeScript does not have a built-in stack class, can use Array as a stack
const stack: number[] = [];
- /* Push elements onto the stack */
+ /* Push elements */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
- /* Access the top element of the stack */
+ /* Access top element */
const peek = stack[stack.length - 1];
- /* Pop an element from the stack */
+ /* Pop element */
const pop = stack.pop();
- /* Get the length of the stack */
+ /* Get stack length */
const size = stack.length;
- /* Check if the stack is empty */
+ /* Check if empty */
const is_empty = stack.length === 0;
```
=== "Dart"
```dart title="stack.dart"
- /* Initialize the stack */
- // Dart does not have a built-in stack class, so List can be used as a stack
+ /* Initialize stack */
+ // Dart does not have a built-in stack class, can use List as a stack
List stack = [];
- /* Push elements onto the stack */
+ /* Push elements */
stack.add(1);
stack.add(3);
stack.add(2);
stack.add(5);
stack.add(4);
- /* Access the top element of the stack */
+ /* Access top element */
int peek = stack.last;
- /* Pop an element from the stack */
+ /* Pop element */
int pop = stack.removeLast();
- /* Get the length of the stack */
+ /* Get stack length */
int size = stack.length;
- /* Check if the stack is empty */
+ /* Check if empty */
bool isEmpty = stack.isEmpty;
```
=== "Rust"
```rust title="stack.rs"
- /* Initialize the stack */
+ /* Initialize stack */
// Use Vec as a stack
let mut stack: Vec = Vec::new();
- /* Push elements onto the stack */
+ /* Push elements */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
- /* Access the top element of the stack */
+ /* Access top element */
let top = stack.last().unwrap();
- /* Pop an element from the stack */
+ /* Pop element */
let pop = stack.pop().unwrap();
- /* Get the length of the stack */
+ /* Get stack length */
let size = stack.len();
- /* Check if the stack is empty */
+ /* Check if empty */
let is_empty = stack.is_empty();
```
@@ -299,7 +299,54 @@ Typically, we can directly use the stack class built into the programming langua
=== "Kotlin"
```kotlin title="stack.kt"
+ /* Initialize stack */
+ val stack = Stack()
+ /* Push elements */
+ stack.push(1)
+ stack.push(3)
+ stack.push(2)
+ stack.push(5)
+ stack.push(4)
+
+ /* Access top element */
+ val peek = stack.peek()
+
+ /* Pop element */
+ val pop = stack.pop()
+
+ /* Get stack length */
+ val size = stack.size
+
+ /* Check if empty */
+ val isEmpty = stack.isEmpty()
+ ```
+
+=== "Ruby"
+
+ ```ruby title="stack.rb"
+ # Initialize stack
+ # Ruby does not have a built-in stack class, can use Array as a stack
+ stack = []
+
+ # Push elements
+ stack << 1
+ stack << 3
+ stack << 2
+ stack << 5
+ stack << 4
+
+ # Access top element
+ peek = stack.last
+
+ # Pop element
+ pop = stack.pop
+
+ # Get stack length
+ size = stack.length
+
+ # Check if empty
+ is_empty = stack.empty?
```
=== "Zig"
@@ -308,24 +355,24 @@ Typically, we can directly use the stack class built into the programming langua
```
-??? pythontutor "Code Visualization"
+??? pythontutor "Visualize Execution"
https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E6%A0%88%0A%20%20%20%20%23%20Python%20%E6%B2%A1%E6%9C%89%E5%86%85%E7%BD%AE%E7%9A%84%E6%A0%88%E7%B1%BB%EF%BC%8C%E5%8F%AF%E4%BB%A5%E6%8A%8A%20list%20%E5%BD%93%E4%BD%9C%E6%A0%88%E6%9D%A5%E4%BD%BF%E7%94%A8%0A%20%20%20%20stack%20%3D%20%5B%5D%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%85%A5%E6%A0%88%0A%20%20%20%20stack.append%281%29%0A%20%20%20%20stack.append%283%29%0A%20%20%20%20stack.append%282%29%0A%20%20%20%20stack.append%285%29%0A%20%20%20%20stack.append%284%29%0A%20%20%20%20print%28%22%E6%A0%88%20stack%20%3D%22,%20stack%29%0A%0A%20%20%20%20%23%20%E8%AE%BF%E9%97%AE%E6%A0%88%E9%A1%B6%E5%85%83%E7%B4%A0%0A%20%20%20%20peek%20%3D%20stack%5B-1%5D%0A%20%20%20%20print%28%22%E6%A0%88%E9%A1%B6%E5%85%83%E7%B4%A0%20peek%20%3D%22,%20peek%29%0A%0A%20%20%20%20%23%20%E5%85%83%E7%B4%A0%E5%87%BA%E6%A0%88%0A%20%20%20%20pop%20%3D%20stack.pop%28%29%0A%20%20%20%20print%28%22%E5%87%BA%E6%A0%88%E5%85%83%E7%B4%A0%20pop%20%3D%22,%20pop%29%0A%20%20%20%20print%28%22%E5%87%BA%E6%A0%88%E5%90%8E%20stack%20%3D%22,%20stack%29%0A%0A%20%20%20%20%23%20%E8%8E%B7%E5%8F%96%E6%A0%88%E7%9A%84%E9%95%BF%E5%BA%A6%0A%20%20%20%20size%20%3D%20len%28stack%29%0A%20%20%20%20print%28%22%E6%A0%88%E7%9A%84%E9%95%BF%E5%BA%A6%20size%20%3D%22,%20size%29%0A%0A%20%20%20%20%23%20%E5%88%A4%E6%96%AD%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%0A%20%20%20%20is_empty%20%3D%20len%28stack%29%20%3D%3D%200%0A%20%20%20%20print%28%22%E6%A0%88%E6%98%AF%E5%90%A6%E4%B8%BA%E7%A9%BA%20%3D%22,%20is_empty%29&cumulative=false&curInstr=2&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false
-## Implementing a stack
+## Stack Implementation
To gain a deeper understanding of how a stack operates, let's try implementing a stack class ourselves.
-A stack follows the principle of Last-In-First-Out, which means we can only add or remove elements at the top of the stack. However, both arrays and linked lists allow adding and removing elements at any position, **therefore a stack can be seen as a restricted array or linked list**. In other words, we can "shield" certain irrelevant operations of an array or linked list, aligning their external behavior with the characteristics of a stack.
+A stack follows the LIFO principle, so we can only add or remove elements at the top. However, both arrays and linked lists allow adding and removing elements at any position. **Therefore, a stack can be viewed as a restricted array or linked list**. In other words, we can "shield" some irrelevant operations of arrays or linked lists so that their external logic conforms to the characteristics of a stack.
-### Implementation based on a linked list
+### Linked List Implementation
-When implementing a stack using a linked list, we can consider the head node of the list as the top of the stack and the tail node as the bottom of the stack.
+When implementing a stack using a linked list, we can treat the head node of the linked list as the top of the stack and the tail node as the base.
-As shown in the figure below, for the push operation, we simply insert elements at the head of the linked list. This method of node insertion is known as "head insertion." For the pop operation, we just need to remove the head node from the list.
+As shown in the figure below, for the push operation, we simply insert an element at the head of the linked list. This node insertion method is called the "head insertion method." For the pop operation, we just need to remove the head node from the linked list.
=== "LinkedListStack"
- 
+ 
=== "push()"
@@ -333,18 +380,18 @@ As shown in the figure below, for the push operation, we simply insert elements
=== "pop()"
-Below is an example code for implementing a stack based on a linked list:
+Below is sample code for implementing a stack based on a linked list:
```src
[file]{linkedlist_stack}-[class]{linked_list_stack}-[func]{}
```
-### Implementation based on an array
+### Array Implementation
-When implementing a stack using an array, we can consider the end of the array as the top of the stack. As shown in the figure below, push and pop operations correspond to adding and removing elements at the end of the array, respectively, both with a time complexity of $O(1)$.
+When implementing a stack using an array, we can treat the end of the array as the top of the stack. As shown in the figure below, push and pop operations correspond to adding and removing elements at the end of the array, both with a time complexity of $O(1)$.
=== "ArrayStack"
- 
+ 
=== "push()"
@@ -352,38 +399,38 @@ When implementing a stack using an array, we can consider the end of the array a
=== "pop()"
-Since the elements to be pushed onto the stack may continuously increase, we can use a dynamic array, thus avoiding the need to handle array expansion ourselves. Here is an example code:
+Since elements pushed onto the stack may increase continuously, we can use a dynamic array, which eliminates the need to handle array expansion ourselves. Here is the sample code:
```src
[file]{array_stack}-[class]{array_stack}-[func]{}
```
-## Comparison of the two implementations
+## Comparison of the Two Implementations
**Supported Operations**
-Both implementations support all the operations defined in a stack. The array implementation additionally supports random access, but this is beyond the scope of a stack definition and is generally not used.
+Both implementations support all operations defined by the stack. The array implementation additionally supports random access, but this goes beyond the stack definition and is generally not used.
**Time Efficiency**
-In the array-based implementation, both push and pop operations occur in pre-allocated contiguous memory, which has good cache locality and therefore higher efficiency. However, if the push operation exceeds the array capacity, it triggers a resizing mechanism, making the time complexity of that push operation $O(n)$.
+In the array-based implementation, both push and pop operations occur in pre-allocated contiguous memory, which has good cache locality and is therefore more efficient. However, if pushing exceeds the array capacity, it triggers an expansion mechanism, causing the time complexity of that particular push operation to become $O(n)$.
-In the linked list implementation, list expansion is very flexible, and there is no efficiency decrease issue as in array expansion. However, the push operation requires initializing a node object and modifying pointers, so its efficiency is relatively lower. If the elements being pushed are already node objects, then the initialization step can be skipped, improving efficiency.
+In the linked list-based implementation, list expansion is very flexible, and there is no issue of reduced efficiency due to array expansion. However, the push operation requires initializing a node object and modifying pointers, so it is relatively less efficient. Nevertheless, if the pushed elements are already node objects, the initialization step can be omitted, thereby improving efficiency.
-Thus, when the elements for push and pop operations are basic data types like `int` or `double`, we can draw the following conclusions:
+In summary, when the elements pushed and popped are basic data types such as `int` or `double`, we can draw the following conclusions:
-- The array-based stack implementation's efficiency decreases during expansion, but since expansion is a low-frequency operation, its average efficiency is higher.
-- The linked list-based stack implementation provides more stable efficiency performance.
+- The array-based stack implementation has reduced efficiency when expansion is triggered, but since expansion is an infrequent operation, the average efficiency is higher.
+- The linked list-based stack implementation can provide more stable efficiency performance.
**Space Efficiency**
-When initializing a list, the system allocates an "initial capacity," which might exceed the actual need; moreover, the expansion mechanism usually increases capacity by a specific factor (like doubling), which may also exceed the actual need. Therefore, **the array-based stack might waste some space**.
+When initializing a list, the system allocates an "initial capacity" that may exceed the actual need. Additionally, the expansion mechanism typically expands at a specific ratio (e.g., 2x), and the capacity after expansion may also exceed actual needs. Therefore, **the array-based stack implementation may cause some space wastage**.
-However, since linked list nodes require extra space for storing pointers, **the space occupied by linked list nodes is relatively larger**.
+However, since linked list nodes need to store additional pointers, **the space occupied by linked list nodes is relatively large**.
-In summary, we cannot simply determine which implementation is more memory-efficient. It requires analysis based on specific circumstances.
+In summary, we cannot simply determine which implementation is more memory-efficient and need to analyze the specific situation.
-## Typical applications of stack
+## Typical Applications of Stack
-- **Back and forward in browsers, undo and redo in software**. Every time we open a new webpage, the browser pushes the previous page onto the stack, allowing us to go back to the previous page through the back operation, which is essentially a pop operation. To support both back and forward, two stacks are needed to work together.
-- **Memory management in programs**. Each time a function is called, the system adds a stack frame at the top of the stack to record the function's context information. In recursive functions, the downward recursion phase keeps pushing onto the stack, while the upward backtracking phase keeps popping from the stack.
+- **Back and forward in browsers, undo and redo in software**. Every time we open a new webpage, the browser pushes the previous page onto the stack, allowing us to return to the previous page via the back operation. The back operation is essentially performing a pop. To support both back and forward, two stacks are needed to work together.
+- **Program memory management**. Each time a function is called, the system adds a stack frame to the top of the stack to record the function's context information. During recursion, the downward recursive phase continuously performs push operations, while the upward backtracking phase continuously performs pop operations.
diff --git a/en/docs/chapter_stack_and_queue/summary.md b/en/docs/chapter_stack_and_queue/summary.md
index a76a81433..ff8551353 100644
--- a/en/docs/chapter_stack_and_queue/summary.md
+++ b/en/docs/chapter_stack_and_queue/summary.md
@@ -1,31 +1,31 @@
# Summary
-### Key review
+### Key Review
-- Stack is a data structure that follows the Last-In-First-Out (LIFO) principle and can be implemented using arrays or linked lists.
-- In terms of time efficiency, the array implementation of the stack has a higher average efficiency. However, during expansion, the time complexity for a single push operation can degrade to $O(n)$. In contrast, the linked list implementation of a stack offers more stable efficiency.
-- Regarding space efficiency, the array implementation of the stack may lead to a certain degree of space wastage. However, it's important to note that the memory space occupied by nodes in a linked list is generally larger than that for elements in an array.
-- A queue is a data structure that follows the First-In-First-Out (FIFO) principle, and it can also be implemented using arrays or linked lists. The conclusions regarding time and space efficiency for queues are similar to those for stacks.
-- A double-ended queue (deque) is a more flexible type of queue that allows adding and removing elements at both ends.
+- A stack is a data structure that follows the LIFO principle and can be implemented using arrays or linked lists.
+- In terms of time efficiency, the array implementation of a stack has higher average efficiency, but during expansion, the time complexity of a single push operation degrades to $O(n)$. In contrast, the linked list implementation of a stack provides more stable efficiency performance.
+- In terms of space efficiency, the array implementation of a stack may lead to some degree of space wastage. However, it should be noted that the memory space occupied by linked list nodes is larger than that of array elements.
+- A queue is a data structure that follows the FIFO principle and can also be implemented using arrays or linked lists. The conclusions regarding time efficiency and space efficiency comparisons for queues are similar to those for stacks mentioned above.
+- A deque is a queue with greater flexibility that allows adding and removing elements at both ends.
### Q & A
**Q**: Is the browser's forward and backward functionality implemented with a doubly linked list?
-A browser's forward and backward navigation is essentially a manifestation of the "stack" concept. When a user visits a new page, the page is added to the top of the stack; when they click the back button, the page is popped from the top of the stack. A double-ended queue (deque) can conveniently implement some additional operations, as mentioned in the "Double-Ended Queue" section.
+The forward and backward functionality of a browser is essentially a manifestation of a "stack." When a user visits a new page, that page is added to the top of the stack; when the user clicks the back button, that page is popped from the top of the stack. Using a deque can conveniently implement some additional operations, as mentioned in the "Deque" section.
-**Q**: After popping from a stack, is it necessary to free the memory of the popped node?
+**Q**: After popping from the stack, do we need to free the memory of the popped node?
-If the popped node will still be used later, it's not necessary to free its memory. In languages like Java and Python that have automatic garbage collection, manual memory release is not necessary; in C and C++, manual memory release is required.
+If the popped node will still be needed later, then memory does not need to be freed. If it won't be used afterward, languages like Java and Python have automatic garbage collection, so manual memory deallocation is not required; in C and C++, manual memory deallocation is necessary.
-**Q**: A double-ended queue seems like two stacks joined together. What are its uses?
+**Q**: A deque seems like two stacks joined together. What is its purpose?
-A double-ended queue, which is a combination of a stack and a queue or two stacks joined together, exhibits both stack and queue logic. Thus, it can implement all applications of stacks and queues while offering more flexibility.
+A deque is like a combination of a stack and a queue, or two stacks joined together. It exhibits the logic of both stack and queue, so it can implement all applications of stacks and queues, and is more flexible.
-**Q**: How exactly are undo and redo implemented?
+**Q**: How are undo and redo specifically implemented?
-Undo and redo operations are implemented using two stacks: Stack `A` for undo and Stack `B` for redo.
+Use two stacks: stack `A` for undo and stack `B` for redo.
-1. Each time a user performs an operation, it is pushed onto Stack `A`, and Stack `B` is cleared.
-2. When the user executes an "undo", the most recent operation is popped from Stack `A` and pushed onto Stack `B`.
-3. When the user executes a "redo", the most recent operation is popped from Stack `B` and pushed back onto Stack `A`.
+1. Whenever the user performs an operation, push this operation onto stack `A` and clear stack `B`.
+2. When the user performs "undo," pop the most recent operation from stack `A` and push it onto stack `B`.
+3. When the user performs "redo," pop the most recent operation from stack `B` and push it onto stack `A`.
diff --git a/en/docs/chapter_tree/array_representation_of_tree.md b/en/docs/chapter_tree/array_representation_of_tree.md
index a2e814a58..5c1bc0433 100644
--- a/en/docs/chapter_tree/array_representation_of_tree.md
+++ b/en/docs/chapter_tree/array_representation_of_tree.md
@@ -1,6 +1,6 @@
# Array representation of binary trees
-Under the linked list representation, the storage unit of a binary tree is a node `TreeNode`, with nodes connected by pointers. The basic operations of binary trees under the linked list representation were introduced in the previous section.
+Under the linked list representation, the storage unit of a binary tree is a node `TreeNode`, and nodes are connected by pointers. The previous section introduced the basic operations of binary trees under the linked list representation.
So, can we use an array to represent a binary tree? The answer is yes.
@@ -8,7 +8,7 @@ So, can we use an array to represent a binary tree? The answer is yes.
Let's analyze a simple case first. Given a perfect binary tree, we store all nodes in an array according to the order of level-order traversal, where each node corresponds to a unique array index.
-Based on the characteristics of level-order traversal, we can deduce a "mapping formula" between the index of a parent node and its children: **If a node's index is $i$, then the index of its left child is $2i + 1$ and the right child is $2i + 2$**. The figure below shows the mapping relationship between the indices of various nodes.
+Based on the characteristics of level-order traversal, we can derive a "mapping formula" between parent node index and child node indices: **If a node's index is $i$, then its left child index is $2i + 1$ and its right child index is $2i + 2$**. The figure below shows the mapping relationships between various node indices.
@@ -16,7 +16,7 @@ Based on the characteristics of level-order traversal, we can deduce a "mapping
## Representing any binary tree
-Perfect binary trees are a special case; there are often many `None` values in the middle levels of a binary tree. Since the sequence of level-order traversal does not include these `None` values, we cannot solely rely on this sequence to deduce the number and distribution of `None` values. **This means that multiple binary tree structures can match the same level-order traversal sequence**.
+Perfect binary trees are a special case; in the middle levels of a binary tree, there are typically many `None` values. Since the level-order traversal sequence does not include these `None` values, we cannot infer the number and distribution of `None` values based on this sequence alone. **This means multiple binary tree structures can correspond to the same level-order traversal sequence**.
As shown in the figure below, given a non-perfect binary tree, the above method of array representation fails.
@@ -117,13 +117,15 @@ To solve this problem, **we can consider explicitly writing out all `None` value
```kotlin title=""
/* Array representation of a binary tree */
// Using null to represent empty slots
- val tree = mutableListOf( 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 )
+ val tree = arrayOf( 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 )
```
=== "Ruby"
```ruby title=""
-
+ ### Array representation of a binary tree ###
+ # Using nil to represent empty slots
+ tree = [1, 2, 3, 4, nil, 6, 7, 8, 9, nil, nil, 12, nil, nil, 15]
```
=== "Zig"
@@ -134,7 +136,7 @@ To solve this problem, **we can consider explicitly writing out all `None` value
-It's worth noting that **complete binary trees are very suitable for array representation**. Recalling the definition of a complete binary tree, `None` appears only at the bottom level and towards the right, **meaning all `None` values definitely appear at the end of the level-order traversal sequence**.
+It's worth noting that **complete binary trees are very well-suited for array representation**. Recalling the definition of a complete binary tree, `None` only appears at the bottom level and towards the right, **meaning all `None` values must appear at the end of the level-order traversal sequence**.
This means that when using an array to represent a complete binary tree, it's possible to omit storing all `None` values, which is very convenient. The figure below gives an example.
@@ -142,8 +144,8 @@ This means that when using an array to represent a complete binary tree, it's po
The following code implements a binary tree based on array representation, including the following operations:
-- Given a node, obtain its value, left (right) child node, and parent node.
-- Obtain the pre-order, in-order, post-order, and level-order traversal sequences.
+- Given a certain node, obtain its value, left (right) child node, and parent node.
+- Obtain the preorder, inorder, postorder, and level-order traversal sequences.
```src
[file]{array_binary_tree}-[class]{array_binary_tree}-[func]{}
@@ -153,12 +155,12 @@ The following code implements a binary tree based on array representation, inclu
The array representation of binary trees has the following advantages:
-- Arrays are stored in contiguous memory spaces, which is cache-friendly and allows for faster access and traversal.
+- Arrays are stored in contiguous memory space, which is cache-friendly, allowing faster access and traversal.
- It does not require storing pointers, which saves space.
- It allows random access to nodes.
However, the array representation also has some limitations:
- Array storage requires contiguous memory space, so it is not suitable for storing trees with a large amount of data.
-- Adding or deleting nodes requires array insertion and deletion operations, which are less efficient.
+- Adding or removing nodes requires array insertion and deletion operations, which have lower efficiency.
- When there are many `None` values in the binary tree, the proportion of node data contained in the array is low, leading to lower space utilization.
diff --git a/en/docs/chapter_tree/avl_tree.md b/en/docs/chapter_tree/avl_tree.md
index 68bd5e088..1d6d1ca56 100644
--- a/en/docs/chapter_tree/avl_tree.md
+++ b/en/docs/chapter_tree/avl_tree.md
@@ -1,6 +1,6 @@
# AVL tree *
-In the "Binary Search Tree" section, we mentioned that after multiple insertions and removals, a binary search tree might degrade to a linked list. In such cases, the time complexity of all operations degrades from $O(\log n)$ to $O(n)$.
+In the "Binary Search Tree" section, we mentioned that after multiple insertion and removal operations, a binary search tree may degenerate into a linked list. In this case, the time complexity of all operations degrades from $O(\log n)$ to $O(n)$.
As shown in the figure below, after two node removal operations, this binary search tree will degrade into a linked list.
@@ -10,11 +10,11 @@ For example, in the perfect binary tree shown in the figure below, after inserti
-In 1962, G. M. Adelson-Velsky and E. M. Landis proposed the AVL Tree in their paper "An algorithm for the organization of information". The paper detailed a series of operations to ensure that after continuously adding and removing nodes, the AVL tree would not degrade, thus maintaining the time complexity of various operations at $O(\log n)$ level. In other words, in scenarios where frequent additions, removals, searches, and modifications are needed, the AVL tree can always maintain efficient data operation performance, which has great application value.
+In 1962, G. M. Adelson-Velsky and E. M. Landis proposed the AVL tree in their paper "An algorithm for the organization of information". The paper described in detail a series of operations ensuring that after continuously adding and removing nodes, the AVL tree does not degenerate, thus keeping the time complexity of various operations at the $O(\log n)$ level. In other words, in scenarios requiring frequent insertions, deletions, searches, and modifications, the AVL tree can always maintain efficient data operation performance, making it very valuable in applications.
## Common terminology in AVL trees
-An AVL tree is both a binary search tree and a balanced binary tree, satisfying all properties of these two types of binary trees, hence it is a balanced binary search tree.
+An AVL tree is both a binary search tree and a balanced binary tree, simultaneously satisfying all the properties of these two types of binary trees, hence it is a balanced binary search tree.
### Node height
@@ -180,7 +180,7 @@ Since the operations related to AVL trees require obtaining node heights, we nee
```c title=""
/* AVL tree node */
- TreeNode struct TreeNode {
+ typedef struct TreeNode {
int val;
int height;
struct TreeNode *left;
@@ -214,7 +214,18 @@ Since the operations related to AVL trees require obtaining node heights, we nee
=== "Ruby"
```ruby title=""
+ ### AVL tree node class ###
+ class TreeNode
+ attr_accessor :val # Node value
+ attr_accessor :height # Node height
+ attr_accessor :left # Left child reference
+ attr_accessor :right # Right child reference
+ def initialize(val)
+ @val = val
+ @height = 0
+ end
+ end
```
=== "Zig"
@@ -231,7 +242,7 @@ The "node height" refers to the distance from that node to its farthest leaf nod
### Node balance factor
-The balance factor of a node is defined as the height of the node's left subtree minus the height of its right subtree, with the balance factor of a null node defined as $0$. We will also encapsulate the functionality of obtaining the node balance factor into a function for easy use later on:
+The balance factor of a node is defined as the height of the node's left subtree minus the height of its right subtree, and the balance factor of a null node is defined as $0$. We also encapsulate the function to obtain the node's balance factor for convenient subsequent use:
```src
[file]{avl_tree}-[class]{avl_tree}-[func]{balance_factor}
@@ -243,13 +254,13 @@ The balance factor of a node is defined as the height of the node's left
## Rotations in AVL trees
-The characteristic feature of an AVL tree is the "rotation" operation, which can restore balance to an unbalanced node without affecting the in-order traversal sequence of the binary tree. In other words, **the rotation operation can maintain the property of a "binary search tree" while also turning the tree back into a "balanced binary tree"**.
+The characteristic of AVL trees lies in the "rotation" operation, which can restore balance to unbalanced nodes without affecting the inorder traversal sequence of the binary tree. In other words, **rotation operations can both maintain the property of a "binary search tree" and make the tree return to a "balanced binary tree"**.
-We call nodes with an absolute balance factor $> 1$ "unbalanced nodes". Depending on the type of imbalance, there are four kinds of rotations: right rotation, left rotation, right-left rotation, and left-right rotation. Below, we detail these rotation operations.
+We call nodes with a balance factor absolute value $> 1$ "unbalanced nodes". Depending on the imbalance situation, rotation operations are divided into four types: right rotation, left rotation, left rotation then right rotation, and right rotation then left rotation. Below we describe these rotation operations in detail.
### Right rotation
-As shown in the figure below, the first unbalanced node from the bottom up in the binary tree is "node 3". Focusing on the subtree with this unbalanced node as the root, denoted as `node`, and its left child as `child`, perform a "right rotation". After the right rotation, the subtree is balanced again while still maintaining the properties of a binary search tree.
+As shown in the figure below, the value below the node is the balance factor. From bottom to top, the first unbalanced node in the binary tree is "node 3". We focus on the subtree with this unbalanced node as the root, denoting the node as `node` and its left child as `child`, and perform a "right rotation" operation. After the right rotation is completed, the subtree regains balance and still maintains the properties of a binary search tree.
=== "<1>"
@@ -283,42 +294,42 @@ Similarly, as shown in the figure below, when the `child` node has a left child
-It can be observed that **the right and left rotation operations are logically symmetrical, and they solve two symmetrical types of imbalance**. Based on symmetry, by replacing all `left` with `right`, and all `right` with `left` in the implementation code of right rotation, we can get the implementation code for left rotation:
+It can be observed that **right rotation and left rotation operations are mirror symmetric in logic, and the two imbalance cases they solve are also symmetric**. Based on symmetry, we only need to replace all `left` in the right rotation implementation code with `right`, and all `right` with `left`, to obtain the left rotation implementation code:
```src
[file]{avl_tree}-[class]{avl_tree}-[func]{left_rotate}
```
-### Left-right rotation
+### Left rotation then right rotation
-For the unbalanced node 3 shown in the figure below, using either left or right rotation alone cannot restore balance to the subtree. In this case, a "left rotation" needs to be performed on `child` first, followed by a "right rotation" on `node`.
+For the unbalanced node 3 in the figure below, using either left rotation or right rotation alone cannot restore the subtree to balance. In this case, a "left rotation" needs to be performed on `child` first, followed by a "right rotation" on `node`.
-### Right-left rotation
+### Right rotation then left rotation
-As shown in the figure below, for the mirror case of the above unbalanced binary tree, a "right rotation" needs to be performed on `child` first, followed by a "left rotation" on `node`.
+As shown in the figure below, for the mirror case of the above unbalanced binary tree, a "right rotation" needs to be performed on `child` first, then a "left rotation" on `node`.
### Choice of rotation
-The four kinds of imbalances shown in the figure below correspond to the cases described above, respectively requiring right rotation, left-right rotation, right-left rotation, and left rotation.
+The four imbalances shown in the figure below correspond one-to-one with the above cases, requiring right rotation, left rotation then right rotation, right rotation then left rotation, and left rotation operations respectively.
-As shown in the table below, we determine which of the above cases an unbalanced node belongs to by judging the sign of the balance factor of the unbalanced node and its higher-side child's balance factor.
+As shown in the table below, we determine which case the unbalanced node belongs to by judging the signs of the balance factor of the unbalanced node and the balance factor of its taller-side child node.
Table Conditions for Choosing Among the Four Rotation Cases
-| Balance factor of unbalanced node | Balance factor of child node | Rotation method to use |
-| --------------------------------- | ---------------------------- | --------------------------------- |
-| $> 1$ (Left-leaning tree) | $\geq 0$ | Right rotation |
-| $> 1$ (Left-leaning tree) | $<0$ | Left rotation then right rotation |
-| $< -1$ (Right-leaning tree) | $\leq 0$ | Left rotation |
-| $< -1$ (Right-leaning tree) | $>0$ | Right rotation then left rotation |
+| Balance factor of the unbalanced node | Balance factor of the child node | Rotation method to apply |
+| -------------------------------------- | --------------------------------- | --------------------------------- |
+| $> 1$ (left-leaning tree) | $\geq 0$ | Right rotation |
+| $> 1$ (left-leaning tree) | $<0$ | Left rotation then right rotation |
+| $< -1$ (right-leaning tree) | $\leq 0$ | Left rotation |
+| $< -1$ (right-leaning tree) | $>0$ | Right rotation then left rotation |
-For convenience, we encapsulate the rotation operations into a function. **With this function, we can perform rotations on various kinds of imbalances, restoring balance to unbalanced nodes**. The code is as follows:
+For ease of use, we encapsulate the rotation operations into a function. **With this function, we can perform rotations for various imbalance situations, restoring balance to unbalanced nodes**. The code is as follows:
```src
[file]{avl_tree}-[class]{avl_tree}-[func]{rotate}
@@ -328,7 +339,7 @@ For convenience, we encapsulate the rotation operations into a function. **With
### Node insertion
-The node insertion operation in AVL trees is similar to that in binary search trees. The only difference is that after inserting a node in an AVL tree, a series of unbalanced nodes may appear along the path from that node to the root node. Therefore, **we need to start from this node and perform rotation operations upwards to restore balance to all unbalanced nodes**. The code is as follows:
+The node insertion operation in AVL trees is similar in principle to that in binary search trees. The only difference is that after inserting a node in an AVL tree, a series of unbalanced nodes may appear on the path from that node to the root. Therefore, **we need to start from this node and perform rotation operations from bottom to top, restoring balance to all unbalanced nodes**. The code is as follows:
```src
[file]{avl_tree}-[class]{avl_tree}-[func]{insert_helper}
@@ -336,7 +347,7 @@ The node insertion operation in AVL trees is similar to that in binary search tr
### Node removal
-Similarly, based on the method of removing nodes in binary search trees, rotation operations need to be performed from the bottom up to restore balance to all unbalanced nodes. The code is as follows:
+Similarly, on the basis of the binary search tree's node removal method, rotation operations need to be performed from bottom to top to restore balance to all unbalanced nodes. The code is as follows:
```src
[file]{avl_tree}-[class]{avl_tree}-[func]{remove_helper}
@@ -344,10 +355,10 @@ Similarly, based on the method of removing nodes in binary search trees, rotatio
### Node search
-The node search operation in AVL trees is consistent with that in binary search trees and will not be detailed here.
+The node search operation in AVL trees is consistent with that in binary search trees, and will not be elaborated here.
## Typical applications of AVL trees
-- Organizing and storing large amounts of data, suitable for scenarios with high-frequency searches and low-frequency intertions and removals.
+- Organizing and storing large-scale data, suitable for scenarios with high-frequency searches and low-frequency insertions and deletions.
- Used to build index systems in databases.
-- Red-black trees are also a common type of balanced binary search tree. Compared to AVL trees, red-black trees have more relaxed balancing conditions, require fewer rotations for node insertion and removal, and have a higher average efficiency for node addition and removal operations.
+- Red-black trees are also a common type of balanced binary search tree. Compared to AVL trees, red-black trees have more relaxed balance conditions, require fewer rotation operations for node insertion and deletion, and have higher average efficiency for node addition and deletion operations.
diff --git a/en/docs/chapter_tree/binary_search_tree.md b/en/docs/chapter_tree/binary_search_tree.md
index 881973801..d9fd02a0a 100755
--- a/en/docs/chapter_tree/binary_search_tree.md
+++ b/en/docs/chapter_tree/binary_search_tree.md
@@ -13,7 +13,7 @@ We encapsulate the binary search tree as a class `BinarySearchTree` and declare
### Searching for a node
-Given a target node value `num`, one can search according to the properties of the binary search tree. As shown in the figure below, we declare a node `cur`, start from the binary tree's root node `root`, and loop to compare the size between the node value `cur.val` and `num`.
+Given a target node value `num`, we can search according to the properties of the binary search tree. As shown in the figure below, we declare a node `cur` and start from the binary tree's root node `root`, looping to compare the node value `cur.val` with `num`.
- If `cur.val < num`, it means the target node is in `cur`'s right subtree, thus execute `cur = cur.right`.
- If `cur.val > num`, it means the target node is in `cur`'s left subtree, thus execute `cur = cur.left`.
@@ -31,7 +31,7 @@ Given a target node value `num`, one can search according to the properties of t
=== "<4>"
-The search operation in a binary search tree works on the same principle as the binary search algorithm, eliminating half of the cases in each round. The number of loops is at most the height of the binary tree. When the binary tree is balanced, it uses $O(\log n)$ time. The example code is as follows:
+The search operation in a binary search tree works on the same principle as the binary search algorithm, both eliminating half of the cases in each round. The number of loop iterations is at most the height of the binary tree. When the binary tree is balanced, it uses $O(\log n)$ time. The example code is as follows:
```src
[file]{binary_search_tree}-[class]{binary_search_tree}-[func]{search}
@@ -39,17 +39,17 @@ The search operation in a binary search tree works on the same principle as the
### Inserting a node
-Given an element `num` to be inserted, to maintain the property of the binary search tree "left subtree < root node < right subtree," the insertion operation proceeds as shown in the figure below.
+Given an element `num` to be inserted, in order to maintain the property of the binary search tree "left subtree < root node < right subtree," the insertion process is as shown in the figure below.
-1. **Finding insertion position**: Similar to the search operation, start from the root node, loop downwards according to the size relationship between the current node value and `num`, until the leaf node is passed (traversed to `None`), then exit the loop.
-2. **Insert the node at this position**: Initialize the node `num` and place it where `None` was.
+1. **Finding the insertion position**: Similar to the search operation, start from the root node and loop downward searching according to the size relationship between the current node value and `num`, until passing the leaf node (traversing to `None`) and then exit the loop.
+2. **Insert the node at that position**: Initialize node `num` and place it at the `None` position.
-In the code implementation, note the following two points.
+In the code implementation, note the following two points:
-- The binary search tree does not allow duplicate nodes to exist; otherwise, its definition would be violated. Therefore, if the node to be inserted already exists in the tree, the insertion is not performed, and the node returns directly.
-- To perform the insertion operation, we need to use the node `pre` to save the node from the previous loop. This way, when traversing to `None`, we can get its parent node, thus completing the node insertion operation.
+- Binary search trees do not allow duplicate nodes; otherwise, it would violate its definition. Therefore, if the node to be inserted already exists in the tree, the insertion is not performed and it returns directly.
+- To implement the node insertion, we need to use node `pre` to save the node from the previous loop iteration. This way, when traversing to `None`, we can obtain its parent node, thereby completing the node insertion operation.
```src
[file]{binary_search_tree}-[class]{binary_search_tree}-[func]{insert}
@@ -59,7 +59,7 @@ Similar to searching for a node, inserting a node uses $O(\log n)$ time.
### Removing a node
-First, find the target node in the binary tree, then remove it. Similar to inserting a node, we need to ensure that after the removal operation is completed, the property of the binary search tree "left subtree < root node < right subtree" is still satisfied. Therefore, based on the number of child nodes of the target node, we divide it into three cases: 0, 1, and 2, and perform the corresponding node removal operations.
+First, find the target node in the binary tree, then remove it. Similar to node insertion, we need to ensure that after the removal operation is completed, the binary search tree's property of "left subtree $<$ root node $<$ right subtree" is still maintained. Therefore, depending on the number of child nodes the target node has, we divide it into 0, 1, and 2 three cases, and execute the corresponding node removal operations.
As shown in the figure below, when the degree of the node to be removed is $0$, it means the node is a leaf node and can be directly removed.
@@ -69,12 +69,12 @@ As shown in the figure below, when the degree of the node to be removed is $1$,
-When the degree of the node to be removed is $2$, we cannot remove it directly, but need to use a node to replace it. To maintain the property of the binary search tree "left subtree $<$ root node $<$ right subtree," **this node can be either the smallest node of the right subtree or the largest node of the left subtree**.
+When the degree of the node to be removed is $2$, we cannot directly remove it; instead, we need to use a node to replace it. To maintain the binary search tree's property of "left subtree $<$ root node $<$ right subtree," **this node can be either the smallest node in the right subtree or the largest node in the left subtree**.
-Assuming we choose the smallest node of the right subtree (the next node in in-order traversal), then the removal operation proceeds as shown in the figure below.
+Assuming we choose the smallest node in the right subtree (the next node in the inorder traversal), the removal process is as shown in the figure below.
-1. Find the next node in the "in-order traversal sequence" of the node to be removed, denoted as `tmp`.
-2. Replace the value of the node to be removed with `tmp`'s value, and recursively remove the node `tmp` in the tree.
+1. Find the next node of the node to be removed in the "inorder traversal sequence," denoted as `tmp`.
+2. Replace the value of the node to be removed with the value of `tmp`, and recursively remove node `tmp` in the tree.
=== "<1>"
@@ -88,25 +88,25 @@ Assuming we choose the smallest node of the right subtree (the next node in in-o
=== "<4>"
-The operation of removing a node also uses $O(\log n)$ time, where finding the node to be removed requires $O(\log n)$ time, and obtaining the in-order traversal successor node requires $O(\log n)$ time. Example code is as follows:
+The node removal operation also uses $O(\log n)$ time, where finding the node to be removed requires $O(\log n)$ time, and obtaining the inorder successor node requires $O(\log n)$ time. Example code is as follows:
```src
[file]{binary_search_tree}-[class]{binary_search_tree}-[func]{remove}
```
-### In-order traversal is ordered
+### Inorder traversal is ordered
-As shown in the figure below, the in-order traversal of a binary tree follows the traversal order of "left $\rightarrow$ root $\rightarrow$ right," and a binary search tree satisfies the size relationship of "left child node $<$ root node $<$ right child node."
+As shown in the figure below, the inorder traversal of a binary tree follows the "left $\rightarrow$ root $\rightarrow$ right" traversal order, while the binary search tree satisfies the "left child node $<$ root node $<$ right child node" size relationship.
-This means that when performing in-order traversal in a binary search tree, the next smallest node will always be traversed first, thus leading to an important property: **The sequence of in-order traversal in a binary search tree is ascending**.
+This means that when performing an inorder traversal in a binary search tree, the next smallest node is always traversed first, thus yielding an important property: **The inorder traversal sequence of a binary search tree is ascending**.
-Using the ascending property of in-order traversal, obtaining ordered data in a binary search tree requires only $O(n)$ time, without the need for additional sorting operations, which is very efficient.
+Using the property of inorder traversal being ascending, we can obtain ordered data in a binary search tree in only $O(n)$ time, without the need for additional sorting operations, which is very efficient.
-
+
## Efficiency of binary search trees
-Given a set of data, we consider using an array or a binary search tree for storage. Observing the table below, the operations on a binary search tree all have logarithmic time complexity, which is stable and efficient. Arrays are more efficient than binary search trees only in scenarios involving frequent additions and infrequent searches or removals.
+Given a set of data, we consider using an array or a binary search tree for storage. Observing the table below, all operations in a binary search tree have logarithmic time complexity, providing stable and efficient performance. Arrays are more efficient than binary search trees only in scenarios with high-frequency additions and low-frequency searches and deletions.
Table Efficiency comparison between arrays and search trees
@@ -116,7 +116,7 @@ Given a set of data, we consider using an array or a binary search tree for stor
| Insert element | $O(1)$ | $O(\log n)$ |
| Remove element | $O(n)$ | $O(\log n)$ |
-Ideally, the binary search tree is "balanced," allowing any node can be found within $\log n$ loops.
+In the ideal case, a binary search tree is "balanced," such that any node can be found within $\log n$ loop iterations.
However, if we continuously insert and remove nodes in a binary search tree, it may degenerate into a linked list as shown in the figure below, where the time complexity of various operations also degrades to $O(n)$.
diff --git a/en/docs/chapter_tree/binary_tree.md b/en/docs/chapter_tree/binary_tree.md
index b06570218..cbbe299e2 100644
--- a/en/docs/chapter_tree/binary_tree.md
+++ b/en/docs/chapter_tree/binary_tree.md
@@ -1,6 +1,6 @@
# Binary tree
-A binary tree is a non-linear data structure that represents the hierarchical relationship between ancestors and descendants and embodies the divide-and-conquer logic of "splitting into two". Similar to a linked list, the basic unit of a binary tree is a node, and each node contains a value, a reference to its left child node, and a reference to its right child node.
+A binary tree is a non-linear data structure that represents the derivation relationship between "ancestors" and "descendants" and embodies the divide-and-conquer logic of "one divides into two". Similar to a linked list, the basic unit of a binary tree is a node, and each node contains a value, a reference to its left child node, and a reference to its right child node.
=== "Python"
@@ -189,7 +189,16 @@ A binary tree is a non-linear data structure that represents the hierarch
=== "Ruby"
```ruby title=""
+ ### Binary tree node class ###
+ class TreeNode
+ attr_accessor :val # Node value
+ attr_accessor :left # Reference to left child node
+ attr_accessor :right # Reference to right child node
+ def initialize(val)
+ @val = val
+ end
+ end
```
=== "Zig"
@@ -432,7 +441,18 @@ Similar to a linked list, the initialization of a binary tree involves first cre
=== "Ruby"
```ruby title="binary_tree.rb"
-
+ # Initializing a binary tree
+ # Initializing nodes
+ n1 = TreeNode.new(1)
+ n2 = TreeNode.new(2)
+ n3 = TreeNode.new(3)
+ n4 = TreeNode.new(4)
+ n5 = TreeNode.new(5)
+ # Linking references (pointers) between nodes
+ n1.left = n2
+ n1.right = n3
+ n2.left = n4
+ n2.right = n5
```
=== "Zig"
@@ -594,7 +614,13 @@ Similar to a linked list, inserting and removing nodes in a binary tree can be a
=== "Ruby"
```ruby title="binary_tree.rb"
-
+ # Inserting and removing nodes
+ _p = TreeNode.new(0)
+ # Inserting node _p between n1 and n2
+ n1.left = _p
+ _p.left = n2
+ # Removing node _p
+ n1.left = n2
```
=== "Zig"
@@ -615,7 +641,7 @@ Similar to a linked list, inserting and removing nodes in a binary tree can be a
### Perfect binary tree
-As shown in the figure below, in a perfect binary tree, all levels are completely filled with nodes. In a perfect binary tree, leaf nodes have a degree of $0$, while all other nodes have a degree of $2$. The total number of nodes can be calculated as $2^{h+1} - 1$, where $h$ is the height of the tree. This exhibits a standard exponential relationship, reflecting the common phenomenon of cell division in nature.
+As shown in the figure below, a perfect binary tree has all levels completely filled with nodes. In a perfect binary tree, leaf nodes have a degree of $0$, while all other nodes have a degree of $2$. If the tree height is $h$, the total number of nodes is $2^{h+1} - 1$, exhibiting a standard exponential relationship that reflects the common phenomenon of cell division in nature.
!!! tip
@@ -625,13 +651,13 @@ As shown in the figure below, in a perfect binary tree, all levels are co
### Complete binary tree
-As shown in the figure below, a complete binary tree is a binary tree where only the bottom level is possibly not completely filled, and nodes at the bottom level must be filled continuously from left to right. Note that a perfect binary tree is also a complete binary tree.
+As shown in the figure below, a complete binary tree only allows the bottom level to be incompletely filled, and the nodes at the bottom level must be filled continuously from left to right. Note that a perfect binary tree is also a complete binary tree.
### Full binary tree
-As shown in the figure below, a full binary tree, except for the leaf nodes, has two child nodes for all other nodes.
+As shown in the figure below, in a full binary tree, all nodes except leaf nodes have two child nodes.
@@ -643,10 +669,10 @@ As shown in the figure below, in a balanced binary tree, the absolute dif
## Degeneration of binary trees
-The figure below shows the ideal and degenerate structures of binary trees. A binary tree becomes a "perfect binary tree" when every level is filled; while it degenerates into a "linked list" when all nodes are biased toward one side.
+The figure below shows the ideal and degenerate structures of binary trees. When every level of a binary tree is filled, it reaches the "perfect binary tree" state; when all nodes are biased toward one side, the binary tree degenerates into a "linked list".
-- A perfect binary tree is an ideal scenario where the "divide and conquer" advantage of a binary tree can be fully utilized.
-- On the other hand, a linked list represents another extreme where all operations become linear, resulting in a time complexity of $O(n)$.
+- A perfect binary tree is the ideal case, fully leveraging the "divide and conquer" advantage of binary trees.
+- A linked list represents the other extreme, where all operations become linear operations with time complexity degrading to $O(n)$.
diff --git a/en/docs/chapter_tree/binary_tree_traversal.md b/en/docs/chapter_tree/binary_tree_traversal.md
index 08c104605..c0c1308c4 100755
--- a/en/docs/chapter_tree/binary_tree_traversal.md
+++ b/en/docs/chapter_tree/binary_tree_traversal.md
@@ -8,13 +8,13 @@ The common traversal methods for binary trees include level-order traversal, pre
As shown in the figure below, level-order traversal traverses the binary tree from top to bottom, layer by layer. Within each level, it visits nodes from left to right.
-Level-order traversal is essentially a type of breadth-first traversal, also known as breadth-first search (BFS), which embodies a "circumferentially outward expanding" layer-by-layer traversal method.
+Level-order traversal is essentially breadth-first traversal, also known as breadth-first search (BFS), which embodies a "expanding outward circle by circle" layer-by-layer traversal method.
### Code implementation
-Breadth-first traversal is usually implemented with the help of a "queue". The queue follows the "first in, first out" rule, while breadth-first traversal follows the "layer-by-layer progression" rule, the underlying ideas of the two are consistent. The implementation code is as follows:
+Breadth-first traversal is typically implemented with the help of a "queue". The queue follows the "first in, first out" rule, while breadth-first traversal follows the "layer-by-layer progression" rule; the underlying ideas of the two are consistent. The implementation code is as follows:
```src
[file]{binary_tree_bfs}-[class]{}-[func]{level_order}
@@ -22,16 +22,16 @@ Breadth-first traversal is usually implemented with the help of a "queue". The q
### Complexity analysis
-- **Time complexity is $O(n)$**: All nodes are visited once, taking $O(n)$ time, where $n$ is the number of nodes.
-- **Space complexity is $O(n)$**: In the worst case, i.e., a full binary tree, before traversing to the bottom level, the queue can contain at most $(n + 1) / 2$ nodes simultaneously, occupying $O(n)$ space.
+- **Time complexity is $O(n)$**: All nodes are visited once, using $O(n)$ time, where $n$ is the number of nodes.
+- **Space complexity is $O(n)$**: In the worst case, i.e., a full binary tree, before traversing to the bottom level, the queue contains at most $(n + 1) / 2$ nodes simultaneously, occupying $O(n)$ space.
-## Preorder, in-order, and post-order traversal
+## Preorder, inorder, and postorder traversal
-Correspondingly, pre-order, in-order, and post-order traversal all belong to depth-first traversal, also known as depth-first search (DFS), which embodies a "proceed to the end first, then backtrack and continue" traversal method.
+Correspondingly, preorder, inorder, and postorder traversals all belong to depth-first traversal, also known as depth-first search (DFS), which embodies a "first go to the end, then backtrack and continue" traversal method.
-The figure below shows the working principle of performing a depth-first traversal on a binary tree. **Depth-first traversal is like "walking" around the entire binary tree**, encountering three positions at each node, corresponding to pre-order, in-order, and post-order traversal.
+The figure below shows how depth-first traversal works on a binary tree. **Depth-first traversal is like "walking" around the perimeter of the entire binary tree**, encountering three positions at each node, corresponding to preorder, inorder, and postorder traversal.
-
+
### Code implementation
@@ -45,13 +45,13 @@ Depth-first search is usually implemented based on recursion:
Depth-first search can also be implemented based on iteration, interested readers can study this on their own.
-The figure below shows the recursive process of pre-order traversal of a binary tree, which can be divided into two opposite parts: "recursion" and "return".
+The figure below shows the recursive process of preorder traversal of a binary tree, which can be divided into two opposite parts: "recursion" and "return".
-1. "Recursion" means starting a new method, the program accesses the next node in this process.
-2. "Return" means the function returns, indicating the current node has been fully accessed.
+1. "Recursion" means opening a new method, where the program accesses the next node in this process.
+2. "Return" means the function returns, indicating that the current node has been fully visited.
=== "<1>"
- 
+ 
=== "<2>"
@@ -86,4 +86,4 @@ The figure below shows the recursive process of pre-order traversal of a binary
### Complexity analysis
- **Time complexity is $O(n)$**: All nodes are visited once, using $O(n)$ time.
-- **Space complexity is $O(n)$**: In the worst case, i.e., the tree degenerates into a linked list, the recursion depth reaches $n$, the system occupies $O(n)$ stack frame space.
+- **Space complexity is $O(n)$**: In the worst case, i.e., the tree degenerates into a linked list, the recursion depth reaches $n$, and the system occupies $O(n)$ stack frame space.
diff --git a/en/docs/chapter_tree/index.md b/en/docs/chapter_tree/index.md
index f65885391..f641a4a14 100644
--- a/en/docs/chapter_tree/index.md
+++ b/en/docs/chapter_tree/index.md
@@ -4,6 +4,6 @@
!!! abstract
- The towering tree exudes a vibrant essence, boasting profound roots and abundant foliage, yet its branches are sparsely scattered, creating an ethereal aura.
-
- It shows us the vivid form of divide-and-conquer in data.
\ No newline at end of file
+ Towering trees are full of vitality, with deep roots and lush leaves, spreading branches and flourishing.
+
+ They show us the vivid form of divide and conquer in data.
\ No newline at end of file
diff --git a/en/docs/chapter_tree/summary.md b/en/docs/chapter_tree/summary.md
index 93f64a4b9..22cea3590 100644
--- a/en/docs/chapter_tree/summary.md
+++ b/en/docs/chapter_tree/summary.md
@@ -2,17 +2,17 @@
### Key review
-- A binary tree is a non-linear data structure that reflects the "divide and conquer" logic of splitting one into two. Each binary tree node contains a value and two pointers, which point to its left and right child nodes, respectively.
-- For a node in a binary tree, its left (right) child node and the tree formed below it are collectively called the node's left (right) subtree.
-- Terms related to binary trees include root node, leaf node, level, degree, edge, height, and depth.
-- The operations of initializing a binary tree, inserting nodes, and removing nodes are similar to those of linked list operations.
-- Common types of binary trees include perfect binary trees, complete binary trees, full binary trees, and balanced binary trees. The perfect binary tree represents the ideal state, while the linked list is the worst state after degradation.
-- A binary tree can be represented using an array by arranging the node values and empty slots in a level-order traversal sequence and implementing pointers based on the index mapping relationship between parent nodes and child nodes.
-- The level-order traversal of a binary tree is a breadth-first search method, which reflects a layer-by-layer traversal manner of "expanding circle by circle." It is usually implemented using a queue.
-- Pre-order, in-order, and post-order traversals are all depth-first search methods, reflecting the traversal manner of "going to the end first, then backtracking to continue." They are usually implemented using recursion.
-- A binary search tree is an efficient data structure for element searching, with the time complexity of search, insert, and remove operations all being $O(\log n)$. When a binary search tree degrades into a linked list, these time complexities deteriorate to $O(n)$.
-- An AVL tree, also known as a balanced binary search tree, ensures that the tree remains balanced after continuous node insertions and removals through rotation operations.
-- Rotation operations in an AVL tree include right rotation, left rotation, right-left rotation, and left-right rotation. After node insertion or removal, the AVL tree rebalances itself by performing these rotations in a bottom-up manner.
+- A binary tree is a non-linear data structure that embodies the divide-and-conquer logic of "one divides into two". Each binary tree node contains a value and two pointers, which respectively point to its left and right child nodes.
+- For a certain node in a binary tree, the tree formed by its left (right) child node and all nodes below is called the left (right) subtree of that node.
+- Related terminology of binary trees includes root node, leaf node, level, degree, edge, height, and depth.
+- The initialization, node insertion, and node removal operations of binary trees are similar to those of linked lists.
+- Common types of binary trees include perfect binary trees, complete binary trees, full binary trees, and balanced binary trees. The perfect binary tree is the ideal state, while the linked list is the worst state after degradation.
+- A binary tree can be represented using an array by arranging node values and empty slots in level-order traversal sequence, and implementing pointers based on the index mapping relationship between parent and child nodes.
+- Level-order traversal of a binary tree is a breadth-first search method, embodying a layer-by-layer traversal approach of "expanding outward circle by circle", typically implemented using a queue.
+- Preorder, inorder, and postorder traversals all belong to depth-first search, embodying a traversal approach of "first go to the end, then backtrack and continue", typically implemented using recursion.
+- A binary search tree is an efficient data structure for element searching, with search, insertion, and removal operations all having time complexity of $O(\log n)$. When a binary search tree degenerates into a linked list, all time complexities degrade to $O(n)$.
+- An AVL tree, also known as a balanced binary search tree, ensures the tree remains balanced after continuous node insertions and removals through rotation operations.
+- Rotation operations in AVL trees include right rotation, left rotation, left rotation then right rotation, and right rotation then left rotation. After inserting or removing nodes, AVL trees perform rotation operations from bottom to top to restore the tree to balance.
### Q & A
@@ -24,21 +24,21 @@ Yes, because height and depth are typically defined as "the number of edges pass
Taking the binary search tree as an example, the operation of removing a node needs to be handled in three different scenarios, each requiring multiple steps of node operations.
-**Q**: Why are there three sequences: pre-order, in-order, and post-order for DFS traversal of a binary tree, and what are their uses?
+**Q**: Why does DFS traversal of binary trees have three orders: preorder, inorder, and postorder, and what are their uses?
-Similar to sequential and reverse traversal of arrays, pre-order, in-order, and post-order traversals are three methods of traversing a binary tree, allowing us to obtain a traversal result in a specific order. For example, in a binary search tree, since the node sizes satisfy `left child node value < root node value < right child node value`, we can obtain an ordered node sequence by traversing the tree in the "left $\rightarrow$ root $\rightarrow$ right" priority.
+Similar to forward and reverse traversal of arrays, preorder, inorder, and postorder traversals are three methods of binary tree traversal that allow us to obtain a traversal result in a specific order. For example, in a binary search tree, since nodes satisfy the relationship `left child node value < root node value < right child node value`, we only need to traverse the tree with the priority of "left $\rightarrow$ root $\rightarrow$ right" to obtain an ordered node sequence.
-**Q**: In a right rotation operation that deals with the relationship between the imbalance nodes `node`, `child`, `grand_child`, isn't the connection between `node` and its parent node and the original link of `node` lost after the right rotation?
+**Q**: In a right rotation operation handling the relationship between unbalanced nodes `node`, `child`, and `grand_child`, doesn't the connection between `node` and its parent node get lost after the right rotation?
-We need to view this problem from a recursive perspective. The `right_rotate(root)` operation passes the root node of the subtree and eventually returns the root node of the rotated subtree with `return child`. The connection between the subtree's root node and its parent node is established after this function returns, which is outside the scope of the right rotation operation's maintenance.
+We need to view this problem from a recursive perspective. The right rotation operation `right_rotate(root)` passes in the root node of the subtree and eventually returns the root node of the subtree after rotation with `return child`. The connection between the subtree's root node and its parent node is completed after the function returns, which is not within the maintenance scope of the right rotation operation.
**Q**: In C++, functions are divided into `private` and `public` sections. What considerations are there for this? Why are the `height()` function and the `updateHeight()` function placed in `public` and `private`, respectively?
-It depends on the scope of the method's use. If a method is only used within the class, then it is designed to be `private`. For example, it makes no sense for users to call `updateHeight()` on their own, as it is just a step in the insertion or removal operations. However, `height()` is for accessing node height, similar to `vector.size()`, thus it is set to `public` for use.
+It mainly depends on the method's usage scope. If a method is only used within the class, then it is designed as `private`. For example, calling `updateHeight()` alone by the user makes no sense, as it is only a step in insertion or removal operations. However, `height()` is used to access node height, similar to `vector.size()`, so it is set to `public` for ease of use.
**Q**: How do you build a binary search tree from a set of input data? Is the choice of root node very important?
-Yes, the method for building the tree is provided in the `build_tree()` method in the binary search tree code. As for the choice of the root node, we usually sort the input data and then select the middle element as the root node, recursively building the left and right subtrees. This approach maximizes the balance of the tree.
+Yes, the method for building a tree is provided in the `build_tree()` method in the binary search tree code. As for the choice of root node, we typically sort the input data, then select the middle element as the root node, and recursively build the left and right subtrees. This approach maximizes the tree's balance.
**Q**: In Java, do you always have to use the `equals()` method for string comparison?
@@ -47,7 +47,7 @@ In Java, for primitive data types, `==` is used to compare whether the values of
- `==`: Used to compare whether two variables point to the same object, i.e., whether their positions in memory are the same.
- `equals()`: Used to compare whether the values of two objects are equal.
-Therefore, to compare values, we should use `equals()`. However, strings initialized with `String a = "hi"; String b = "hi";` are stored in the string constant pool and point to the same object, so `a == b` can also be used to compare the contents of two strings.
+Therefore, if we want to compare values, we should use `equals()`. However, strings initialized via `String a = "hi"; String b = "hi";` are stored in the string constant pool and point to the same object, so `a == b` can also be used to compare the contents of the two strings.
**Q**: Before reaching the bottom level, is the number of nodes in the queue $2^h$ in breadth-first traversal?
diff --git a/en/docs/index.html b/en/docs/index.html
index 0a18da586..181fa0d27 100644
--- a/en/docs/index.html
+++ b/en/docs/index.html
@@ -26,7 +26,7 @@
- Hash table
+ Hashing
diff --git a/en/mkdocs.yml b/en/mkdocs.yml
index c98eeabb9..322b55d36 100644
--- a/en/mkdocs.yml
+++ b/en/mkdocs.yml
@@ -9,15 +9,14 @@ docs_dir: ../build/en/docs
site_dir: ../site/en
# Repository
edit_uri: tree/main/en/docs
-version: 1.0.0
+version: 1.2.0
# Configuration
theme:
custom_dir: ../build/overrides
language: en
font:
- text: Roboto
- code: Roboto Mono
+ text: Lato
palette:
- scheme: default
primary: white
@@ -44,9 +43,9 @@ nav:
# [icon: material/book-open-outline]
- chapter_preface/index.md
- 0.1 About this book: chapter_preface/about_the_book.md
- - 0.2 How to read: chapter_preface/suggestions.md
+ - 0.2 How to use this book: chapter_preface/suggestions.md
- 0.3 Summary: chapter_preface/summary.md
- - Chapter 1. Encounter with algorithms:
+ - Chapter 1. Introduction to algorithms:
# [icon: material/calculator-variant-outline]
- chapter_introduction/index.md
- 1.1 Algorithms are everywhere: chapter_introduction/algorithms_are_everywhere.md
@@ -55,7 +54,7 @@ nav:
- Chapter 2. Complexity analysis:
# [icon: material/timer-sand]
- chapter_computational_complexity/index.md
- - 2.1 Algorithm efficiency assessment: chapter_computational_complexity/performance_evaluation.md
+ - 2.1 Algorithm efficiency evaluation: chapter_computational_complexity/performance_evaluation.md
- 2.2 Iteration and recursion: chapter_computational_complexity/iteration_and_recursion.md
- 2.3 Time complexity: chapter_computational_complexity/time_complexity.md
- 2.4 Space complexity: chapter_computational_complexity/space_complexity.md
@@ -83,7 +82,7 @@ nav:
- 5.2 Queue: chapter_stack_and_queue/queue.md
- 5.3 Double-ended queue: chapter_stack_and_queue/deque.md
- 5.4 Summary: chapter_stack_and_queue/summary.md
- - Chapter 6. Hash table:
+ - Chapter 6. Hashing:
# [icon: material/table-search]
- chapter_hashing/index.md
- 6.1 Hash table: chapter_hashing/hash_map.md
@@ -95,8 +94,8 @@ nav:
- chapter_tree/index.md
- 7.1 Binary tree: chapter_tree/binary_tree.md
- 7.2 Binary tree traversal: chapter_tree/binary_tree_traversal.md
- - 7.3 Array Representation of tree: chapter_tree/array_representation_of_tree.md
- - 7.4 Binary Search tree: chapter_tree/binary_search_tree.md
+ - 7.3 Array representation of tree: chapter_tree/array_representation_of_tree.md
+ - 7.4 Binary search tree: chapter_tree/binary_search_tree.md
- 7.5 AVL tree *: chapter_tree/avl_tree.md
- 7.6 Summary: chapter_tree/summary.md
- Chapter 8. Heap:
@@ -110,7 +109,7 @@ nav:
# [icon: material/graphql]
- chapter_graph/index.md
- 9.1 Graph: chapter_graph/graph.md
- - 9.2 Basic graph operations: chapter_graph/graph_operations.md
+ - 9.2 Basic operations on graphs: chapter_graph/graph_operations.md
- 9.3 Graph traversal: chapter_graph/graph_traversal.md
- 9.4 Summary: chapter_graph/summary.md
- Chapter 10. Searching:
@@ -118,8 +117,8 @@ nav:
- chapter_searching/index.md
- 10.1 Binary search: chapter_searching/binary_search.md
- 10.2 Binary search insertion: chapter_searching/binary_search_insertion.md
- - 10.3 Binary search boundaries: chapter_searching/binary_search_edge.md
- - 10.4 Hashing optimization strategies: chapter_searching/replace_linear_by_hashing.md
+ - 10.3 Binary search edge cases: chapter_searching/binary_search_edge.md
+ - 10.4 Hash optimization strategy: chapter_searching/replace_linear_by_hashing.md
- 10.5 Search algorithms revisited: chapter_searching/searching_algorithm_revisited.md
- 10.6 Summary: chapter_searching/summary.md
- Chapter 11. Sorting:
@@ -141,31 +140,31 @@ nav:
- chapter_divide_and_conquer/index.md
- 12.1 Divide and conquer algorithms: chapter_divide_and_conquer/divide_and_conquer.md
- 12.2 Divide and conquer search strategy: chapter_divide_and_conquer/binary_search_recur.md
- - 12.3 Building binary tree problem: chapter_divide_and_conquer/build_binary_tree_problem.md
- - 12.4 Tower of Hanoi Problem: chapter_divide_and_conquer/hanota_problem.md
+ - 12.3 Building a binary tree problem: chapter_divide_and_conquer/build_binary_tree_problem.md
+ - 12.4 Hanoi tower problem: chapter_divide_and_conquer/hanota_problem.md
- 12.5 Summary: chapter_divide_and_conquer/summary.md
- Chapter 13. Backtracking:
# [icon: material/map-marker-path]
- chapter_backtracking/index.md
- - 13.1 Backtracking algorithms: chapter_backtracking/backtracking_algorithm.md
- - 13.2 Permutation problem: chapter_backtracking/permutations_problem.md
- - 13.3 Subset sum problem: chapter_backtracking/subset_sum_problem.md
- - 13.4 n queens problem: chapter_backtracking/n_queens_problem.md
+ - 13.1 Backtracking Algorithm: chapter_backtracking/backtracking_algorithm.md
+ - 13.2 Permutations Problem: chapter_backtracking/permutations_problem.md
+ - 13.3 Subset-Sum Problem: chapter_backtracking/subset_sum_problem.md
+ - 13.4 n-queens problem: chapter_backtracking/n_queens_problem.md
- 13.5 Summary: chapter_backtracking/summary.md
- Chapter 14. Dynamic programming:
# [icon: material/table-pivot]
- chapter_dynamic_programming/index.md
- 14.1 Introduction to dynamic programming: chapter_dynamic_programming/intro_to_dynamic_programming.md
- - 14.2 Characteristics of DP problems: chapter_dynamic_programming/dp_problem_features.md
- - 14.3 DP problem-solving approach¶: chapter_dynamic_programming/dp_solution_pipeline.md
- - 14.4 0-1 Knapsack problem: chapter_dynamic_programming/knapsack_problem.md
+ - 14.2 Characteristics of dynamic programming problems: chapter_dynamic_programming/dp_problem_features.md
+ - 14.3 Dynamic programming problem-solving approach: chapter_dynamic_programming/dp_solution_pipeline.md
+ - 14.4 0-1 knapsack problem: chapter_dynamic_programming/knapsack_problem.md
- 14.5 Unbounded knapsack problem: chapter_dynamic_programming/unbounded_knapsack_problem.md
- 14.6 Edit distance problem: chapter_dynamic_programming/edit_distance_problem.md
- 14.7 Summary: chapter_dynamic_programming/summary.md
- Chapter 15. Greedy:
# [icon: material/head-heart-outline]
- chapter_greedy/index.md
- - 15.1 Greedy algorithms: chapter_greedy/greedy_algorithm.md
+ - 15.1 Greedy algorithm: chapter_greedy/greedy_algorithm.md
- 15.2 Fractional knapsack problem: chapter_greedy/fractional_knapsack_problem.md
- 15.3 Maximum capacity problem: chapter_greedy/max_capacity_problem.md
- 15.4 Maximum product cutting problem: chapter_greedy/max_product_cutting_problem.md
@@ -173,8 +172,8 @@ nav:
- Chapter 16. Appendix:
# [icon: material/help-circle-outline]
- chapter_appendix/index.md
- - 16.1 Installation: chapter_appendix/installation.md
- - 16.2 Contributing: chapter_appendix/contribution.md
- - 16.3 Terminology: chapter_appendix/terminology.md
+ - 16.1 Programming environment installation: chapter_appendix/installation.md
+ - 16.2 Contributing Together: chapter_appendix/contribution.md
+ - 16.3 Terminology Table: chapter_appendix/terminology.md
- References:
- chapter_reference/index.md
diff --git a/ja/mkdocs.yml b/ja/mkdocs.yml
index 4a2906e09..af099f820 100644
--- a/ja/mkdocs.yml
+++ b/ja/mkdocs.yml
@@ -9,7 +9,7 @@ docs_dir: ../build/ja/docs
site_dir: ../site/ja
# Repository
edit_uri: tree/main/ja/docs
-version: 1.0.0
+version: 1.2.0
# Configuration
theme:
@@ -17,7 +17,6 @@ theme:
language: ja
font:
text: Noto Sans JP
- code: Fira Code
palette:
- scheme: default
primary: white
diff --git a/mkdocs.yml b/mkdocs.yml
index 7b96608f1..63feb0274 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -19,6 +19,9 @@ theme:
name: material
custom_dir: build/overrides
language: zh
+ font:
+ text: Noto Sans SC
+ code: JetBrains Mono
features:
# - announce.dismiss
- content.action.edit
@@ -56,9 +59,6 @@ theme:
toggle:
icon: material/theme-light-dark
name: 浅色模式
- font:
- text: Noto Sans SC
- code: Fira Code
favicon: assets/images/favicon.png
logo: assets/images/logo.svg
icon: