贡献者
-本书在开源社区一百多位贡献者的共同努力下不断完善，感谢他们付出的时间与精力！
+本书在开源社区 200 多位贡献者的共同努力下不断完善，感谢他们付出的时间与精力！
-| | Hard Disk | Memory | Cache |
-| ---------- | -------------------------------------------------------------- | ------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------- |
-| Usage | Long-term storage of data, including OS, programs, files, etc. | Temporary storage of currently running programs and data being processed | Stores frequently accessed data and instructions, reducing the number of CPU accesses to memory |
-| Volatility | Data is not lost after power off | Data is lost after power off | Data is lost after power off |
-| Capacity | Larger, TB level | Smaller, GB level | Very small, MB level |
-| Speed | Slower, several hundred to thousands MB/s | Faster, several tens of GB/s | Very fast, several tens to hundreds of GB/s |
-| Price | Cheaper, a few cents to a few dollars / GB | More expensive, tens to hundreds of dollars / GB | Very expensive, priced with CPU |
+| | Hard Disk | Memory | Cache |
+| ----------- | -------------------------------------------------------------- | ------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------- |
+| Usage | Long-term storage of data, including OS, programs, files, etc. | Temporary storage of currently running programs and data being processed | Stores frequently accessed data and instructions, reducing the number of CPU accesses to memory |
+| Volatility | Data is not lost after power off | Data is lost after power off | Data is lost after power off |
+| Capacity | Larger, TB level | Smaller, GB level | Very small, MB level |
+| Speed | Slower, several hundred to thousands MB/s | Faster, several tens of GB/s | Very fast, several tens to hundreds of GB/s |
+| Price (USD) | Cheaper, a few cents / GB | More expensive, a few dollars / GB | Very expensive, priced with CPU |
diff --git a/en/docs/chapter_computational_complexity/space_complexity.md b/en/docs/chapter_computational_complexity/space_complexity.md
index 51cfe9e97..20c5571b8 100644
--- a/en/docs/chapter_computational_complexity/space_complexity.md
+++ b/en/docs/chapter_computational_complexity/space_complexity.md
@@ -517,7 +517,7 @@ Consider the following code, the term "worst-case" in worst-case space complexit
/* Recursion O(n) */
void recur(int n) {
if (n == 1) return;
- return recur(n - 1);
+ recur(n - 1);
}
```
@@ -537,7 +537,7 @@ Consider the following code, the term "worst-case" in worst-case space complexit
/* Recursion O(n) */
void recur(int n) {
if (n == 1) return;
- return recur(n - 1);
+ recur(n - 1);
}
```
@@ -666,7 +666,7 @@ Consider the following code, the term "worst-case" in worst-case space complexit
/* Recursion O(n) */
void recur(int n) {
if (n == 1) return;
- return recur(n - 1);
+ recur(n - 1);
}
```
@@ -708,7 +708,7 @@ Consider the following code, the term "worst-case" in worst-case space complexit
/* Recursion O(n) */
void recur(int n) {
if (n == 1) return;
- return recur(n - 1);
+ recur(n - 1);
}
```
diff --git a/en/docs/chapter_divide_and_conquer/build_binary_tree_problem.md b/en/docs/chapter_divide_and_conquer/build_binary_tree_problem.md
index 39b2f552a..98dcb4252 100644
--- a/en/docs/chapter_divide_and_conquer/build_binary_tree_problem.md
+++ b/en/docs/chapter_divide_and_conquer/build_binary_tree_problem.md
@@ -35,7 +35,7 @@ Using the data from the preceding figure, we can follow the steps shown in the n
2. Find the index of the root node 3 in the `inorder` sequence, and use this index to split `inorder` into `[ 9 | 3 ｜ 1 2 7 ]`.
3. According to the split of the `inorder` sequence, it is straightforward to determine that the left and right subtrees contain 1 and 3 nodes, respectively, so we can split the `preorder` sequence into `[ 3 | 9 | 2 1 7 ]` accordingly.
-{ class="animation-figure" }
+{ class="animation-figure" }
Figure 12-6 Dividing the subtrees in pre-order and in-order traversals
diff --git a/en/docs/chapter_hello_algo/index.md b/en/docs/chapter_hello_algo/index.md index 0dc41f39e..6953f39a5 100644 --- a/en/docs/chapter_hello_algo/index.md +++ b/en/docs/chapter_hello_algo/index.md @@ -7,13 +7,13 @@ icon: material/rocket-launch-outline 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. -Directly solving problems seems to be the most popular method — it's simple, direct, and effective. However, problem-solving is like playing a game of Minesweeper: those with strong self-study abilities can defuse the mines one by one, but those with insufficient basics might end up metaphorically bruised from explosions, retreating step by step in frustration. Going through textbooks is also common, but for those aiming for job applications, the energy spent on thesis writing, resume submissions, and preparation for written tests and interviews leaves little for tackling thick books, turning it into a daunting challenge. +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. -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. This book may not directly land you an offer, but it will guide you through the "knowledge map" in data structures and algorithms, help you understand the shapes, sizes, and locations of different "mines," and enable you to master various "demining 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 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. -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." To not disappoint the precious "attention" you pay for this book, I will do my best, dedicating my utmost "attention" to this book. +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. -Knowing my limitations, although the content of this book has been refined over time, there are surely many errors remaining. I sincerely request critiques and corrections from all teachers and students. +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. { class="cover-image" } diff --git a/en/docs/chapter_introduction/algorithms_are_everywhere.md b/en/docs/chapter_introduction/algorithms_are_everywhere.md index e16ffaae5..8db90c332 100644 --- a/en/docs/chapter_introduction/algorithms_are_everywhere.md +++ b/en/docs/chapter_introduction/algorithms_are_everywhere.md @@ -4,63 +4,63 @@ comments: true # 1.1 Algorithms are everywhere -When we hear the word "algorithm," we naturally think of mathematics. However, many algorithms do not involve complex mathematics but rely more on basic logic, which can be seen everywhere in our daily lives. +When we hear the term "algorithm," we naturally think of mathematics. However, many algorithms do not involve complex mathematics but rely more on basic logic, which can be seen everywhere in our daily lives. -Before formally discussing algorithms, there's an interesting fact worth sharing: **you have already unconsciously learned many algorithms and have become accustomed to applying them in your daily life**. Here, I will give a few specific examples to prove this point. +Before we start discussing about algorithms officially, there's an interesting fact worth sharing: **you've learned many algorithms unconsciously and are used to applying them in your daily life**. Here, I will give a few specific examples to prove this point. -**Example 1: Looking Up a Dictionary**. In an English dictionary, words are listed alphabetically. Suppose we're searching for a word that starts with the letter $r$. This is typically done in the following way: +**Example 1: Looking Up a Dictionary**. In an English dictionary, words are listed alphabetically. Assuming we're searching for a word that starts with the letter $r$, this is typically done in the following way: -1. Open the dictionary to about halfway and check the first letter on the page, let's say the letter is $m$. -2. Since $r$ comes after $m$ in the alphabet, we can ignore the first half of the dictionary and focus on the latter half. +1. Open the dictionary to about halfway and check the first vocabulary of the page, let's say the letter starts with $m$. +2. Since $r$ comes after $m$ in the alphabet, the first half can be ignored and the search space is narrowed down to the second half. 3. Repeat steps `1.` and `2.` until you find the page where the word starts with $r$. === "<1>" - { class="animation-figure" } + { class="animation-figure" } === "<2>" - { class="animation-figure" } + { class="animation-figure" } === "<3>" - { class="animation-figure" } + { class="animation-figure" } === "<4>" - { class="animation-figure" } + { class="animation-figure" } === "<5>" - { class="animation-figure" } + { class="animation-figure" } -Figure 1-1 Process of Looking Up a Dictionary
+Figure 1-1 Process of looking up a dictionary
-This essential skill for elementary students, looking up a dictionary, is actually the famous "Binary Search" algorithm. From a data structure perspective, we can consider the dictionary as a sorted "array"; from an algorithmic perspective, the series of actions taken to look up a word in the dictionary can be viewed as "Binary Search." +Looking up a dictionary, an essential skill for elementary school students is actually the famous "Binary Search" algorithm. From a data structure perspective, we can consider the dictionary as a sorted "array"; from an algorithmic perspective, the series of actions taken to look up a word in the dictionary can be viewed as the algorithm "Binary Search." -**Example 2: Organizing Playing Cards**. When playing cards, we need to arrange the cards in our hand in ascending order, as shown in the following process. +**Example 2: Organizing Card Deck**. When playing cards, we need to arrange the cards in our hands in ascending order, as shown in the following process. 1. Divide the playing cards into "ordered" and "unordered" sections, assuming initially the leftmost card is already in order. 2. Take out a card from the unordered section and insert it into the correct position in the ordered section; after this, the leftmost two cards are in order. -3. Continue to repeat step `2.` until all cards are in order. +3. Repeat step `2` until all cards are in order. -{ class="animation-figure" } +{ class="animation-figure" } -Figure 1-2 Playing cards sorting process
+Figure 1-2 Process of sorting a deck of cards
-The above method of organizing playing cards is essentially the "Insertion Sort" algorithm, which is very efficient for small datasets. Many programming languages' sorting functions include the insertion sort. +The above method of organizing playing cards is practically the "Insertion Sort" algorithm, which is very efficient for small datasets. Many programming languages' sorting functions include the insertion sort. -**Example 3: Making Change**. Suppose we buy goods worth $69$ yuan at a supermarket and give the cashier $100$ yuan, then the cashier needs to give us $31$ yuan in change. They would naturally complete the thought process as shown in Figure 1-3. +**Example 3: Making Change**. Assume making a purchase of $69$ at a supermarket. If you give the cashier $100$, they will need to provide you with $31$ in change. This process can be clearly understood as illustrated in Figure 1-3. -1. The options are currencies smaller than $31$, including $1$, $5$, $10$, and $20$. +1. The options are currencies valued below $31$, including $1$, $5$, $10$, and $20$. 2. Take out the largest $20$ from the options, leaving $31 - 20 = 11$. 3. Take out the largest $10$ from the remaining options, leaving $11 - 10 = 1$. 4. Take out the largest $1$ from the remaining options, leaving $1 - 1 = 0$. -5. Complete the change-making, with the solution being $20 + 10 + 1 = 31$. +5. Complete change-making, the solution is $20 + 10 + 1 = 31$. -{ class="animation-figure" } +{ class="animation-figure" } -Figure 1-3 Change making process
+Figure 1-3 Process of making change
-In the above steps, we make the best choice at each step (using the largest denomination possible), ultimately resulting in a feasible change-making plan. From the perspective of data structures and algorithms, this method is essentially a "Greedy" algorithm. +In the steps described, we choose the best option at each stage by utilizing the largest denomination available, which leads to an effective change-making strategy. From a data structures and algorithms perspective, this approach is known as a "Greedy" algorithm. -From cooking a meal to interstellar travel, almost all problem-solving involves algorithms. The advent of computers allows us to store data structures in memory and write code to call the CPU and GPU to execute algorithms. In this way, we can transfer real-life problems to computers, solving various complex issues more efficiently. +From cooking a meal to interstellar travel, almost all problem-solving involves algorithms. The advent of computers allows us to store data structures in memory and write code to call the CPU and GPU to execute algorithms. In this way, we can transfer real-life problems to computers and solve various complex issues in a more efficient way. !!! tip - If concepts such as data structures, algorithms, arrays, and binary search still seem somewhat obscure, I encourage you to continue reading. This book will gently guide you into the realm of understanding data structures and algorithms. + If you are still confused about concepts like data structures, algorithms, arrays, and binary searches, I encourage you to keep reading. This book will gently guide you into the realm of understanding data structures and algorithms. diff --git a/en/docs/chapter_introduction/summary.md b/en/docs/chapter_introduction/summary.md index 44793d319..fb9fd7fc2 100644 --- a/en/docs/chapter_introduction/summary.md +++ b/en/docs/chapter_introduction/summary.md @@ -8,6 +8,19 @@ comments: true - 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 instructions or steps used to solve a specific problem within a finite amount of time, while a data structure is the way data is organized and stored in a computer. +- 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 liken data structures and algorithms to 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. +- 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. + +### 1. 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? + +If specific work skills are like the "moves" in martial arts, then fundamental subjects are more like "internal strength". + +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: + +- 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. + +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. diff --git a/en/docs/chapter_introduction/what_is_dsa.md b/en/docs/chapter_introduction/what_is_dsa.md index 4f5f7bf78..02e9def94 100644 --- a/en/docs/chapter_introduction/what_is_dsa.md +++ b/en/docs/chapter_introduction/what_is_dsa.md @@ -23,14 +23,14 @@ A data structure is a way of organizing and storing data in a computer, w **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: - Compared to arrays, linked lists offer more convenience in data addition and deletion but sacrifice data access speed. -- Graphs, compared to linked lists, provide richer logical information but require more memory space. +- Compared with linked lists, graphs provide richer logical information but require more memory space. ## 1.2.3 Relationship between data structures and algorithms As shown in Figure 1-4, data structures and algorithms are highly related and closely integrated, specifically 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 are the stage where data structures come into play. The data structure alone only stores data information; it is through the application of algorithms that specific problems can be solved. +- 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. { class="animation-figure" } @@ -62,4 +62,4 @@ It's worth noting that data structures and algorithms are independent of program !!! 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 problems actually test both data structure and algorithm knowledge. + 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. diff --git a/en/docs/index.html b/en/docs/index.html index dbedfcc7e..2d16406b0 100644 --- a/en/docs/index.html +++ b/en/docs/index.html @@ -414,7 +414,7 @@Contributors
-This book has been refined by the efforts of over 180 contributors. We sincerely thank them for their invaluable time and contributions!
+This book has been refined by the efforts of over 200 contributors. We sincerely thank them for their invaluable time and contributions!
-| | 硬碟 | 記憶體 | 快取 |
-| ------ | ---------------------------------------- | -------------------------------------- | ------------------------------------------------- |
-| 用途 | 長期儲存資料，包括作業系統、程式、檔案等 | 臨時儲存當前執行的程式和正在處理的資料 | 儲存經常訪問的資料和指令，減少 CPU 訪問記憶體的次數 |
-| 易失性 | 斷電後資料不會丟失 | 斷電後資料會丟失 | 斷電後資料會丟失 |
-| 容量 | 較大，TB 級別 | 較小，GB 級別 | 非常小，MB 級別 |
-| 速度 | 較慢，幾百到幾千 MB/s | 較快，幾十 GB/s | 非常快，幾十到幾百 GB/s |
-| 價格 | 較便宜，幾毛到幾元 / GB | 較貴，幾十到幾百元 / GB | 非常貴，隨 CPU 打包計價 |
+| | 硬碟 | 記憶體 | 快取 |
+| -------------- | ---------------------------------------- | -------------------------------------- | ------------------------------------------------- |
+| 用途 | 長期儲存資料，包括作業系統、程式、檔案等 | 臨時儲存當前執行的程式和正在處理的資料 | 儲存經常訪問的資料和指令，減少 CPU 訪問記憶體的次數 |
+| 易失性 | 斷電後資料不會丟失 | 斷電後資料會丟失 | 斷電後資料會丟失 |
+| 容量 | 較大，TB 級別 | 較小，GB 級別 | 非常小，MB 級別 |
+| 速度 | 較慢，幾百到幾千 MB/s | 較快，幾十 GB/s | 非常快，幾十到幾百 GB/s |
+| 價格（人民幣） | 較便宜，幾毛到幾元 / GB | 較貴，幾十到幾百元 / GB | 非常貴，隨 CPU 打包計價 |
diff --git a/zh-Hant/docs/chapter_backtracking/subset_sum_problem.md b/zh-Hant/docs/chapter_backtracking/subset_sum_problem.md
index 092b26c3d..50f712adc 100644
--- a/zh-Hant/docs/chapter_backtracking/subset_sum_problem.md
+++ b/zh-Hant/docs/chapter_backtracking/subset_sum_problem.md
@@ -17,7 +17,7 @@ comments: true
### 1. 參考全排列解法
-類似於全排列問題，我們可以把子集的生成過程想象成一系列選擇的結果，並在選擇過程中實時更新“元素和”，當元素和等於 `target` 時，就將子集記錄至結果串列。
+類似於全排列問題，我們可以把子集的生成過程想象成一系列選擇的結果，並在選擇過程中即時更新“元素和”，當元素和等於 `target` 時，就將子集記錄至結果串列。
而與全排列問題不同的是，**本題集合中的元素可以被無限次選取**，因此無須藉助 `selected` 布林串列來記錄元素是否已被選擇。我們可以對全排列程式碼進行小幅修改，初步得到解題程式碼：
diff --git a/zh-Hant/docs/chapter_computational_complexity/space_complexity.md b/zh-Hant/docs/chapter_computational_complexity/space_complexity.md
index 6eeba1606..302b9b82f 100755
--- a/zh-Hant/docs/chapter_computational_complexity/space_complexity.md
+++ b/zh-Hant/docs/chapter_computational_complexity/space_complexity.md
@@ -578,7 +578,7 @@ comments: true
/* 遞迴的空間複雜度為 O(n) */
void recur(int n) {
if (n == 1) return;
- return recur(n - 1);
+ recur(n - 1);
}
```
@@ -598,7 +598,7 @@ comments: true
/* 遞迴的空間複雜度為 O(n) */
void recur(int n) {
if (n == 1) return;
- return recur(n - 1);
+ recur(n - 1);
}
```
@@ -727,7 +727,7 @@ comments: true
/* 遞迴的空間複雜度為 O(n) */
void recur(int n) {
if (n == 1) return;
- return recur(n - 1);
+ recur(n - 1);
}
```
@@ -769,7 +769,7 @@ comments: true
/* 遞迴的空間複雜度為 O(n) */
void recur(int n) {
if (n == 1) return;
- return recur(n - 1);
+ recur(n - 1);
}
```
diff --git a/zh-Hant/docs/chapter_data_structure/character_encoding.md b/zh-Hant/docs/chapter_data_structure/character_encoding.md
index f60c2a5ea..06307ed2f 100644
--- a/zh-Hant/docs/chapter_data_structure/character_encoding.md
+++ b/zh-Hant/docs/chapter_data_structure/character_encoding.md
@@ -4,37 +4,37 @@ comments: true
# 3.4 字元編碼 *
-在計算機中，所有資料都是以二進位制數的形式儲存的，字元 `char` 也不例外。為了表示字元，我們需要建立一套“字符集”，規定每個字元和二進位制數之間的一一對應關係。有了字符集之後，計算機就可以透過查表完成二進位制數到字元的轉換。
+在計算機中，所有資料都是以二進位制數的形式儲存的，字元 `char` 也不例外。為了表示字元，我們需要建立一套“字元集”，規定每個字元和二進位制數之間的一一對應關係。有了字元集之後，計算機就可以透過查表完成二進位制數到字元的轉換。
-## 3.4.1 ASCII 字符集
+## 3.4.1 ASCII 字元集
-ASCII 碼是最早出現的字符集，其全稱為 American Standard Code for Information Interchange（美國標準資訊交換程式碼）。它使用 7 位二進位制數（一個位元組的低 7 位）表示一個字元，最多能夠表示 128 個不同的字元。如圖 3-6 所示，ASCII 碼包括英文字母的大小寫、數字 0 ~ 9、一些標點符號，以及一些控制字元（如換行符和製表符）。
+ASCII 碼是最早出現的字元集，其全稱為 American Standard Code for Information Interchange（美國標準資訊交換程式碼）。它使用 7 位二進位制數（一個位元組的低 7 位）表示一個字元，最多能夠表示 128 個不同的字元。如圖 3-6 所示，ASCII 碼包括英文字母的大小寫、數字 0 ~ 9、一些標點符號，以及一些控制字元（如換行符和製表符）。
{ class="animation-figure" }
圖 3-6 ASCII 碼
-然而，**ASCII 碼僅能夠表示英文**。隨著計算機的全球化，誕生了一種能夠表示更多語言的 EASCII 字符集。它在 ASCII 的 7 位基礎上擴展到 8 位，能夠表示 256 個不同的字元。 +然而，**ASCII 碼僅能夠表示英文**。隨著計算機的全球化，誕生了一種能夠表示更多語言的 EASCII 字元集。它在 ASCII 的 7 位基礎上擴展到 8 位，能夠表示 256 個不同的字元。 -在世界範圍內，陸續出現了一批適用於不同地區的 EASCII 字符集。這些字符集的前 128 個字元統一為 ASCII 碼，後 128 個字元定義不同，以適應不同語言的需求。 +在世界範圍內，陸續出現了一批適用於不同地區的 EASCII 字元集。這些字元集的前 128 個字元統一為 ASCII 碼，後 128 個字元定義不同，以適應不同語言的需求。 -## 3.4.2 GBK 字符集 +## 3.4.2 GBK 字元集 -後來人們發現，**EASCII 碼仍然無法滿足許多語言的字元數量要求**。比如漢字有近十萬個，光日常使用的就有幾千個。中國國家標準總局於 1980 年釋出了 GB2312 字符集，其收錄了 6763 個漢字，基本滿足了漢字的計算機處理需要。 +後來人們發現，**EASCII 碼仍然無法滿足許多語言的字元數量要求**。比如漢字有近十萬個，光日常使用的就有幾千個。中國國家標準總局於 1980 年釋出了 GB2312 字元集，其收錄了 6763 個漢字，基本滿足了漢字的計算機處理需要。 -然而，GB2312 無法處理部分罕見字和繁體字。GBK 字符集是在 GB2312 的基礎上擴展得到的，它共收錄了 21886 個漢字。在 GBK 的編碼方案中，ASCII 字元使用一個位元組表示，漢字使用兩個位元組表示。 +然而，GB2312 無法處理部分罕見字和繁體字。GBK 字元集是在 GB2312 的基礎上擴展得到的，它共收錄了 21886 個漢字。在 GBK 的編碼方案中，ASCII 字元使用一個位元組表示，漢字使用兩個位元組表示。 -## 3.4.3 Unicode 字符集 +## 3.4.3 Unicode 字元集 -隨著計算機技術的蓬勃發展，字符集與編碼標準百花齊放，而這帶來了許多問題。一方面，這些字符集一般只定義了特定語言的字元，無法在多語言環境下正常工作。另一方面，同一種語言存在多種字符集標準，如果兩臺計算機使用的是不同的編碼標準，則在資訊傳遞時就會出現亂碼。 +隨著計算機技術的蓬勃發展，字元集與編碼標準百花齊放，而這帶來了許多問題。一方面，這些字元集一般只定義了特定語言的字元，無法在多語言環境下正常工作。另一方面，同一種語言存在多種字元集標準，如果兩臺計算機使用的是不同的編碼標準，則在資訊傳遞時就會出現亂碼。 -那個時代的研究人員就在想：**如果推出一個足夠完整的字符集，將世界範圍內的所有語言和符號都收錄其中，不就可以解決跨語言環境和亂碼問題了嗎**？在這種想法的驅動下，一個大而全的字符集 Unicode 應運而生。 +那個時代的研究人員就在想：**如果推出一個足夠完整的字元集，將世界範圍內的所有語言和符號都收錄其中，不就可以解決跨語言環境和亂碼問題了嗎**？在這種想法的驅動下，一個大而全的字元集 Unicode 應運而生。 -Unicode 的中文名稱為“統一碼”，理論上能容納 100 多萬個字元。它致力於將全球範圍內的字元納入統一的字符集之中，提供一種通用的字符集來處理和顯示各種語言文字，減少因為編碼標準不同而產生的亂碼問題。 +Unicode 的中文名稱為“統一碼”，理論上能容納 100 多萬個字元。它致力於將全球範圍內的字元納入統一的字元集之中，提供一種通用的字元集來處理和顯示各種語言文字，減少因為編碼標準不同而產生的亂碼問題。 -自 1991 年釋出以來，Unicode 不斷擴充新的語言與字元。截至 2022 年 9 月，Unicode 已經包含 149186 個字元，包括各種語言的字元、符號甚至表情符號等。在龐大的 Unicode 字符集中，常用的字元佔用 2 位元組，有些生僻的字元佔用 3 位元組甚至 4 位元組。 +自 1991 年釋出以來，Unicode 不斷擴充新的語言與字元。截至 2022 年 9 月，Unicode 已經包含 149186 個字元，包括各種語言的字元、符號甚至表情符號等。在龐大的 Unicode 字元集中，常用的字元佔用 2 位元組，有些生僻的字元佔用 3 位元組甚至 4 位元組。 -Unicode 是一種通用字符集，本質上是給每個字元分配一個編號（稱為“碼點”），**但它並沒有規定在計算機中如何儲存這些字元碼點**。我們不禁會問：當多種長度的 Unicode 碼點同時出現在一個文字中時，系統如何解析字元？例如給定一個長度為 2 位元組的編碼，系統如何確認它是一個 2 位元組的字元還是兩個 1 位元組的字元？ +Unicode 是一種通用字元集，本質上是給每個字元分配一個編號（稱為“碼點”），**但它並沒有規定在計算機中如何儲存這些字元碼點**。我們不禁會問：當多種長度的 Unicode 碼點同時出現在一個文字中時，系統如何解析字元？例如給定一個長度為 2 位元組的編碼，系統如何確認它是一個 2 位元組的字元還是兩個 1 位元組的字元？ 對於以上問題，**一種直接的解決方案是將所有字元儲存為等長的編碼**。如圖 3-7 所示，“Hello”中的每個字元佔用 1 位元組，“演算法”中的每個字元佔用 2 位元組。我們可以透過高位填 0 將“Hello 演算法”中的所有字元都編碼為 2 位元組長度。這樣系統就可以每隔 2 位元組解析一個字元，恢復這個短語的內容了。 @@ -50,7 +50,7 @@ Unicode 是一種通用字符集，本質上是給每個字元分配一個編號 UTF-8 的編碼規則並不複雜，分為以下兩種情況。 -- 對於長度為 1 位元組的字元，將最高位設定為 $0$ ，其餘 7 位設定為 Unicode 碼點。值得注意的是，ASCII 字元在 Unicode 字符集中佔據了前 128 個碼點。也就是說，**UTF-8 編碼可以向下相容 ASCII 碼**。這意味著我們可以使用 UTF-8 來解析年代久遠的 ASCII 碼文字。 +- 對於長度為 1 位元組的字元，將最高位設定為 $0$ ，其餘 7 位設定為 Unicode 碼點。值得注意的是，ASCII 字元在 Unicode 字元集中佔據了前 128 個碼點。也就是說，**UTF-8 編碼可以向下相容 ASCII 碼**。這意味著我們可以使用 UTF-8 來解析年代久遠的 ASCII 碼文字。 - 對於長度為 $n$ 位元組的字元（其中 $n > 1$），將首個位元組的高 $n$ 位都設定為 $1$ ，第 $n + 1$ 位設定為 $0$ ；從第二個位元組開始，將每個位元組的高 2 位都設定為 $10$ ；其餘所有位用於填充字元的 Unicode 碼點。 圖 3-8 展示了“Hello演算法”對應的 UTF-8 編碼。觀察發現，由於最高 $n$ 位都設定為 $1$ ，因此系統可以透過讀取最高位 $1$ 的個數來解析出字元的長度為 $n$ 。 diff --git a/zh-Hant/docs/chapter_data_structure/summary.md b/zh-Hant/docs/chapter_data_structure/summary.md index 8b48e0918..cc13421fe 100644 --- a/zh-Hant/docs/chapter_data_structure/summary.md +++ b/zh-Hant/docs/chapter_data_structure/summary.md @@ -14,7 +14,7 @@ comments: true - 原碼、一補數和二補數是在計算機中編碼數字的三種方法，它們之間可以相互轉換。整數的原碼的最高位是符號位，其餘位是數字的值。 - 整數在計算機中是以二補數的形式儲存的。在二補數表示下，計算機可以對正數和負數的加法一視同仁，不需要為減法操作單獨設計特殊的硬體電路，並且不存在正負零歧義的問題。 - 浮點數的編碼由 1 位符號位、8 位指數位和 23 位分數位構成。由於存在指數位，因此浮點數的取值範圍遠大於整數，代價是犧牲了精度。 -- ASCII 碼是最早出現的英文字符集，長度為 1 位元組，共收錄 127 個字元。GBK 字符集是常用的中文字符集，共收錄兩萬多個漢字。Unicode 致力於提供一個完整的字符集標準，收錄世界上各種語言的字元，從而解決由於字元編碼方法不一致而導致的亂碼問題。 +- ASCII 碼是最早出現的英文字元集，長度為 1 位元組，共收錄 127 個字元。GBK 字元集是常用的中文字元集，共收錄兩萬多個漢字。Unicode 致力於提供一個完整的字元集標準，收錄世界上各種語言的字元，從而解決由於字元編碼方法不一致而導致的亂碼問題。 - UTF-8 是最受歡迎的 Unicode 編碼方法，通用性非常好。它是一種變長的編碼方法，具有很好的擴展性，有效提升了儲存空間的使用效率。UTF-16 和 UTF-32 是等長的編碼方法。在編碼中文時，UTF-16 佔用的空間比 UTF-8 更小。Java 和 C# 等程式語言預設使用 UTF-16 編碼。 ### 2. Q & A diff --git a/zh-Hant/docs/chapter_greedy/max_product_cutting_problem.md b/zh-Hant/docs/chapter_greedy/max_product_cutting_problem.md index dda1e64dd..fb12f8854 100644 --- a/zh-Hant/docs/chapter_greedy/max_product_cutting_problem.md +++ b/zh-Hant/docs/chapter_greedy/max_product_cutting_problem.md @@ -410,8 +410,8 @@ $$ ### 3. 正確性證明 -使用反證法，只分析 $n \geq 3$ 的情況。 +使用反證法，只分析 $n \geq 4$ 的情況。 -1. **所有因子 $\leq 3$** ：假設最優切分方案中存在 $\geq 4$ 的因子 $x$ ，那麼一定可以將其繼續劃分為 $2(x-2)$ ，從而獲得更大的乘積。這與假設矛盾。 +1. **所有因子 $\leq 3$** ：假設最優切分方案中存在 $\geq 4$ 的因子 $x$ ，那麼一定可以將其繼續劃分為 $2(x-2)$ ，從而獲得更大（或相等）的乘積。這與假設矛盾。 2. **切分方案不包含 $1$** ：假設最優切分方案中存在一個因子 $1$ ，那麼它一定可以合併入另外一個因子中，以獲得更大的乘積。這與假設矛盾。 3. **切分方案最多包含兩個 $2$** ：假設最優切分方案中包含三個 $2$ ，那麼一定可以替換為兩個 $3$ ，乘積更大。這與假設矛盾。 diff --git a/zh-Hant/docs/chapter_sorting/quick_sort.md b/zh-Hant/docs/chapter_sorting/quick_sort.md index 4b4cd3d7c..97d566851 100755 --- a/zh-Hant/docs/chapter_sorting/quick_sort.md +++ b/zh-Hant/docs/chapter_sorting/quick_sort.md @@ -1161,7 +1161,7 @@ comments: true -## 11.5.5 尾遞迴最佳化 +## 11.5.5 遞迴深度最佳化 **在某些輸入下，快速排序可能佔用空間較多**。以完全有序的輸入陣列為例，設遞迴中的子陣列長度為 $m$ ，每輪哨兵劃分操作都將產生長度為 $0$ 的左子陣列和長度為 $m - 1$ 的右子陣列，這意味著每一層遞迴呼叫減少的問題規模非常小（只減少一個元素），遞迴樹的高度會達到 $n - 1$ ，此時需要佔用 $O(n)$ 大小的堆疊幀空間。 @@ -1171,7 +1171,7 @@ comments: true ```python title="quick_sort.py" def quick_sort(self, nums: list[int], left: int, right: int): - """快速排序（尾遞迴最佳化）""" + """快速排序（遞迴深度最佳化）""" # 子陣列長度為 1 時終止 while left < right: # 哨兵劃分操作 @@ -1188,7 +1188,7 @@ comments: true === "C++" ```cpp title="quick_sort.cpp" - /* 快速排序（尾遞迴最佳化） */ + /* 快速排序（遞迴深度最佳化） */ void quickSort(vector貢獻者
-本書在開源社群一百多位貢獻者的共同努力下不斷完善，感謝他們付出的時間與精力！
+本書在開源社群 200 多位貢獻者的共同努力下不斷完善，感謝他們付出的時間與精力！