feat: Traditional Chinese version (#1163)

* First commit

* Update mkdocs.yml

* Translate all the docs to traditional Chinese

* Translate the code files.

* Translate the docker file

* Fix mkdocs.yml

* Translate all the figures from SC to TC

* 二叉搜尋樹 -> 二元搜尋樹

* Update terminology.

* Update terminology

* 构造函数/构造方法 -> 建構子
异或 -> 互斥或

* 擴充套件 -> 擴展

* constant - 常量 - 常數

* 類	-> 類別

* AVL -> AVL 樹

* 數組 -> 陣列

* 係統 -> 系統
斐波那契數列 -> 費波那契數列
運算元量 -> 運算量
引數 -> 參數

* 聯絡 -> 關聯

* 麵試 -> 面試

* 面向物件 -> 物件導向
歸併排序 -> 合併排序
范式 -> 範式

* Fix 算法 -> 演算法

* 錶示 -> 表示
反碼 -> 一補數
補碼 -> 二補數
列列尾部 -> 佇列尾部
區域性性 -> 區域性
一摞 -> 一疊

* Synchronize with main branch

* 賬號 -> 帳號
推匯 -> 推導

* Sync with main branch

* First commit

* Update mkdocs.yml

* Translate all the docs to traditional Chinese

* Translate the code files.

* Translate the docker file

* Fix mkdocs.yml

* Translate all the figures from SC to TC

* 二叉搜尋樹 -> 二元搜尋樹

* Update terminology

* 构造函数/构造方法 -> 建構子
异或 -> 互斥或

* 擴充套件 -> 擴展

* constant - 常量 - 常數

* 類	-> 類別

* AVL -> AVL 樹

* 數組 -> 陣列

* 係統 -> 系統
斐波那契數列 -> 費波那契數列
運算元量 -> 運算量
引數 -> 參數

* 聯絡 -> 關聯

* 麵試 -> 面試

* 面向物件 -> 物件導向
歸併排序 -> 合併排序
范式 -> 範式

* Fix 算法 -> 演算法

* 錶示 -> 表示
反碼 -> 一補數
補碼 -> 二補數
列列尾部 -> 佇列尾部
區域性性 -> 區域性
一摞 -> 一疊

* Synchronize with main branch

* 賬號 -> 帳號
推匯 -> 推導

* Sync with main branch

* Update terminology.md

* 操作数量（num. of operations）-> 操作數量

* 字首和->前綴和

* Update figures

* 歸 -> 迴
記憶體洩漏 -> 記憶體流失

* Fix the bug of the file filter

* 支援 -> 支持
Add zh-Hant/README.md

* Add the zh-Hant chapter covers.
Bug fixes.

* 外掛 -> 擴充功能

* Add the landing page for zh-Hant version

* Unify the font of the chapter covers for the zh, en, and zh-Hant version

* Move zh-Hant/ to zh-hant/

* Translate terminology.md to traditional Chinese

zh-hant/docs/chapter_array_and_linkedlist/array.md

@@ -0,0 +1,230 @@
+# 陣列
+
+<u>陣列（array）</u>是一種線性資料結構，其將相同型別的元素儲存在連續的記憶體空間中。我們將元素在陣列中的位置稱為該元素的<u>索引（index）</u>。下圖展示了陣列的主要概念和儲存方式。
+
+![陣列定義與儲存方式](array.assets/array_definition.png)
+
+## 陣列常用操作
+
+### 初始化陣列
+
+我們可以根據需求選用陣列的兩種初始化方式：無初始值、給定初始值。在未指定初始值的情況下，大多數程式語言會將陣列元素初始化為 $0$ ：
+
+=== "Python"
+
+    ```python title="array.py"
+    # 初始化陣列
+    arr: list[int] = [0] * 5  # [ 0, 0, 0, 0, 0 ]
+    nums: list[int] = [1, 3, 2, 5, 4]  
+    ```
+
+=== "C++"
+
+    ```cpp title="array.cpp"
+    /* 初始化陣列 */
+    // 儲存在堆疊上
+    int arr[5];
+    int nums[5] = { 1, 3, 2, 5, 4 };
+    // 儲存在堆積上（需要手動釋放空間）
+    int* arr1 = new int[5];
+    int* nums1 = new int[5] { 1, 3, 2, 5, 4 };
+    ```
+
+=== "Java"
+
+    ```java title="array.java"
+    /* 初始化陣列 */
+    int[] arr = new int[5]; // { 0, 0, 0, 0, 0 }
+    int[] nums = { 1, 3, 2, 5, 4 };
+    ```
+
+=== "C#"
+
+    ```csharp title="array.cs"
+    /* 初始化陣列 */
+    int[] arr = new int[5]; // [ 0, 0, 0, 0, 0 ]
+    int[] nums = [1, 3, 2, 5, 4];
+    ```
+
+=== "Go"
+
+    ```go title="array.go"
+    /* 初始化陣列 */
+    var arr [5]int
+    // 在 Go 中，指定長度時（[5]int）為陣列，不指定長度時（[]int）為切片
+    // 由於 Go 的陣列被設計為在編譯期確定長度，因此只能使用常數來指定長度
+    // 為了方便實現擴容 extend() 方法，以下將切片（Slice）看作陣列（Array）
+    nums := []int{1, 3, 2, 5, 4}
+    ```
+
+=== "Swift"
+
+    ```swift title="array.swift"
+    /* 初始化陣列 */
+    let arr = Array(repeating: 0, count: 5) // [0, 0, 0, 0, 0]
+    let nums = [1, 3, 2, 5, 4]
+    ```
+
+=== "JS"
+
+    ```javascript title="array.js"
+    /* 初始化陣列 */
+    var arr = new Array(5).fill(0);
+    var nums = [1, 3, 2, 5, 4];
+    ```
+
+=== "TS"
+
+    ```typescript title="array.ts"
+    /* 初始化陣列 */
+    let arr: number[] = new Array(5).fill(0);
+    let nums: number[] = [1, 3, 2, 5, 4];
+    ```
+
+=== "Dart"
+
+    ```dart title="array.dart"
+    /* 初始化陣列 */
+    List<int> arr = List.filled(5, 0); // [0, 0, 0, 0, 0]
+    List<int> nums = [1, 3, 2, 5, 4];
+    ```
+
+=== "Rust"
+
+    ```rust title="array.rs"
+    /* 初始化陣列 */
+    let arr: Vec<i32> = vec![0; 5]; // [0, 0, 0, 0, 0]
+    let nums: Vec<i32> = vec![1, 3, 2, 5, 4];
+    ```
+
+=== "C"
+
+    ```c title="array.c"
+    /* 初始化陣列 */
+    int arr[5] = { 0 }; // { 0, 0, 0, 0, 0 }
+    int nums[5] = { 1, 3, 2, 5, 4 };
+    ```
+
+=== "Kotlin"
+
+    ```kotlin title="array.kt"
+    /* 初始化陣列 */
+    var arr = IntArray(5) // { 0, 0, 0, 0, 0 }
+    var nums = intArrayOf(1, 3, 2, 5, 4)
+    ```
+
+=== "Ruby"
+
+    ```ruby title="array.rb"
+    # 初始化陣列
+    arr = Array.new(5, 0)
+    nums = [1, 3, 2, 5, 4]
+    ```
+
+=== "Zig"
+
+    ```zig title="array.zig"
+    // 初始化陣列
+    var arr = [_]i32{0} ** 5; // { 0, 0, 0, 0, 0 }
+    var nums = [_]i32{ 1, 3, 2, 5, 4 };
+    ```
+
+??? pythontutor "視覺化執行"
+
+    https://pythontutor.com/render.html#code=%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E6%95%B0%E7%BB%84%0Aarr%20%3D%20%5B0%5D%20*%205%20%20%23%20%5B%200,%200,%200,%200,%200%20%5D%0Anums%20%3D%20%5B1,%203,%202,%205,%204%5D&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false
+
+### 訪問元素
+
+陣列元素被儲存在連續的記憶體空間中，這意味著計算陣列元素的記憶體位址非常容易。給定陣列記憶體位址（首元素記憶體位址）和某個元素的索引，我們可以使用下圖所示的公式計算得到該元素的記憶體位址，從而直接訪問該元素。
+
+![陣列元素的記憶體位址計算](array.assets/array_memory_location_calculation.png)
+
+觀察上圖，我們發現陣列首個元素的索引為 $0$ ，這似乎有些反直覺，因為從 $1$ 開始計數會更自然。但從位址計算公式的角度看，**索引本質上是記憶體位址的偏移量**。首個元素的位址偏移量是 $0$ ，因此它的索引為 $0$ 是合理的。
+
+在陣列中訪問元素非常高效，我們可以在 $O(1)$ 時間內隨機訪問陣列中的任意一個元素。
+
+```src
+[file]{array}-[class]{}-[func]{random_access}
+```
+
+### 插入元素
+
+陣列元素在記憶體中是“緊挨著的”，它們之間沒有空間再存放任何資料。如下圖所示，如果想在陣列中間插入一個元素，則需要將該元素之後的所有元素都向後移動一位，之後再把元素賦值給該索引。
+
+![陣列插入元素示例](array.assets/array_insert_element.png)
+
+值得注意的是，由於陣列的長度是固定的，因此插入一個元素必定會導致陣列尾部元素“丟失”。我們將這個問題的解決方案留在“串列”章節中討論。
+
+```src
+[file]{array}-[class]{}-[func]{insert}
+```
+
+### 刪除元素
+
+同理，如下圖所示，若想刪除索引 $i$ 處的元素，則需要把索引 $i$ 之後的元素都向前移動一位。
+
+![陣列刪除元素示例](array.assets/array_remove_element.png)
+
+請注意，刪除元素完成後，原先末尾的元素變得“無意義”了，所以我們無須特意去修改它。
+
+```src
+[file]{array}-[class]{}-[func]{remove}
+```
+
+總的來看，陣列的插入與刪除操作有以下缺點。
+
+- **時間複雜度高**：陣列的插入和刪除的平均時間複雜度均為 $O(n)$ ，其中 $n$ 為陣列長度。
+- **丟失元素**：由於陣列的長度不可變，因此在插入元素後，超出陣列長度範圍的元素會丟失。
+- **記憶體浪費**：我們可以初始化一個比較長的陣列，只用前面一部分，這樣在插入資料時，丟失的末尾元素都是“無意義”的，但這樣做會造成部分記憶體空間浪費。
+
+### 走訪陣列
+
+在大多數程式語言中，我們既可以透過索引走訪陣列，也可以直接走訪獲取陣列中的每個元素：
+
+```src
+[file]{array}-[class]{}-[func]{traverse}
+```
+
+### 查詢元素
+
+在陣列中查詢指定元素需要走訪陣列，每輪判斷元素值是否匹配，若匹配則輸出對應索引。
+
+因為陣列是線性資料結構，所以上述查詢操作被稱為“線性查詢”。
+
+```src
+[file]{array}-[class]{}-[func]{find}
+```
+
+### 擴容陣列
+
+在複雜的系統環境中，程式難以保證陣列之後的記憶體空間是可用的，從而無法安全地擴展陣列容量。因此在大多數程式語言中，**陣列的長度是不可變的**。
+
+如果我們希望擴容陣列，則需重新建立一個更大的陣列，然後把原陣列元素依次複製到新陣列。這是一個 $O(n)$ 的操作，在陣列很大的情況下非常耗時。程式碼如下所示：
+
+```src
+[file]{array}-[class]{}-[func]{extend}
+```
+
+## 陣列的優點與侷限性
+
+陣列儲存在連續的記憶體空間內，且元素型別相同。這種做法包含豐富的先驗資訊，系統可以利用這些資訊來最佳化資料結構的操作效率。
+
+- **空間效率高**：陣列為資料分配了連續的記憶體塊，無須額外的結構開銷。
+- **支持隨機訪問**：陣列允許在 $O(1)$ 時間內訪問任何元素。
+- **快取區域性**：當訪問陣列元素時，計算機不僅會載入它，還會快取其周圍的其他資料，從而藉助高速快取來提升後續操作的執行速度。
+
+連續空間儲存是一把雙刃劍，其存在以下侷限性。
+
+- **插入與刪除效率低**：當陣列中元素較多時，插入與刪除操作需要移動大量的元素。
+- **長度不可變**：陣列在初始化後長度就固定了，擴容陣列需要將所有資料複製到新陣列，開銷很大。
+- **空間浪費**：如果陣列分配的大小超過實際所需，那麼多餘的空間就被浪費了。
+
+## 陣列典型應用
+
+陣列是一種基礎且常見的資料結構，既頻繁應用在各類演算法之中，也可用於實現各種複雜資料結構。
+
+- **隨機訪問**：如果我們想隨機抽取一些樣本，那麼可以用陣列儲存，並生成一個隨機序列，根據索引實現隨機抽樣。
+- **排序和搜尋**：陣列是排序和搜尋演算法最常用的資料結構。快速排序、合併排序、二分搜尋等都主要在陣列上進行。
+- **查詢表**：當需要快速查詢一個元素或其對應關係時，可以使用陣列作為查詢表。假如我們想實現字元到 ASCII 碼的對映，則可以將字元的 ASCII 碼值作為索引，對應的元素存放在陣列中的對應位置。
+- **機器學習**：神經網路中大量使用了向量、矩陣、張量之間的線性代數運算，這些資料都是以陣列的形式構建的。陣列是神經網路程式設計中最常使用的資料結構。
+- **資料結構實現**：陣列可以用於實現堆疊、佇列、雜湊表、堆積、圖等資料結構。例如，圖的鄰接矩陣表示實際上是一個二維陣列。

zh-hant/docs/chapter_array_and_linkedlist/index.md

@@ -0,0 +1,9 @@
+# 陣列與鏈結串列
+
+![陣列與鏈結串列](../assets/covers/chapter_array_and_linkedlist.jpg)
+
+!!! abstract
+
+    資料結構的世界如同一堵厚實的磚牆。
+
+    陣列的磚塊整齊排列，逐個緊貼。鏈結串列的磚塊分散各處，連線的藤蔓自由地穿梭於磚縫之間。

zh-hant/docs/chapter_array_and_linkedlist/linked_list.md

@@ -0,0 +1,761 @@
+# 鏈結串列
+
+記憶體空間是所有程式的公共資源，在一個複雜的系統執行環境下，空閒的記憶體空間可能散落在記憶體各處。我們知道，儲存陣列的記憶體空間必須是連續的，而當陣列非常大時，記憶體可能無法提供如此大的連續空間。此時鏈結串列的靈活性優勢就體現出來了。
+
+<u>鏈結串列（linked list）</u>是一種線性資料結構，其中的每個元素都是一個節點物件，各個節點透過“引用”相連線。引用記錄了下一個節點的記憶體位址，透過它可以從當前節點訪問到下一個節點。
+
+鏈結串列的設計使得各個節點可以分散儲存在記憶體各處，它們的記憶體位址無須連續。
+
+![鏈結串列定義與儲存方式](linked_list.assets/linkedlist_definition.png)
+
+觀察上圖，鏈結串列的組成單位是<u>節點（node）</u>物件。每個節點都包含兩項資料：節點的“值”和指向下一節點的“引用”。
+
+- 鏈結串列的首個節點被稱為“頭節點”，最後一個節點被稱為“尾節點”。
+- 尾節點指向的是“空”，它在 Java、C++ 和 Python 中分別被記為 `null`、`nullptr` 和 `None` 。
+- 在 C、C++、Go 和 Rust 等支持指標的語言中，上述“引用”應被替換為“指標”。
+
+如以下程式碼所示，鏈結串列節點 `ListNode` 除了包含值，還需額外儲存一個引用（指標）。因此在相同資料量下，**鏈結串列比陣列佔用更多的記憶體空間**。
+
+=== "Python"
+
+    ```python title=""
+    class ListNode:
+        """鏈結串列節點類別"""
+        def __init__(self, val: int):
+            self.val: int = val               # 節點值
+            self.next: ListNode | None = None # 指向下一節點的引用
+    ```
+
+=== "C++"
+
+    ```cpp title=""
+    /* 鏈結串列節點結構體 */
+    struct ListNode {
+        int val;         // 節點值
+        ListNode *next;  // 指向下一節點的指標
+        ListNode(int x) : val(x), next(nullptr) {}  // 建構子
+    };
+    ```
+
+=== "Java"
+
+    ```java title=""
+    /* 鏈結串列節點類別 */
+    class ListNode {
+        int val;        // 節點值
+        ListNode next;  // 指向下一節點的引用
+        ListNode(int x) { val = x; }  // 建構子
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+    /* 鏈結串列節點類別 */
+    class ListNode(int x) {  //建構子
+        int val = x;         // 節點值
+        ListNode? next;      // 指向下一節點的引用
+    }
+    ```
+
+=== "Go"
+
+    ```go title=""
+    /* 鏈結串列節點結構體 */
+    type ListNode struct {
+        Val  int       // 節點值
+        Next *ListNode // 指向下一節點的指標
+    }
+
+    // NewListNode 建構子，建立一個新的鏈結串列
+    func NewListNode(val int) *ListNode {
+        return &ListNode{
+            Val:  val,
+            Next: nil,
+        }
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title=""
+    /* 鏈結串列節點類別 */
+    class ListNode {
+        var val: Int // 節點值
+        var next: ListNode? // 指向下一節點的引用
+
+        init(x: Int) { // 建構子
+            val = x
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title=""
+    /* 鏈結串列節點類別 */
+    class ListNode {
+        constructor(val, next) {
+            this.val = (val === undefined ? 0 : val);       // 節點值
+            this.next = (next === undefined ? null : next); // 指向下一節點的引用
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title=""
+    /* 鏈結串列節點類別 */
+    class ListNode {
+        val: number;
+        next: ListNode | null;
+        constructor(val?: number, next?: ListNode | null) {
+            this.val = val === undefined ? 0 : val;        // 節點值
+            this.next = next === undefined ? null : next;  // 指向下一節點的引用
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title=""
+    /* 鏈結串列節點類別 */
+    class ListNode {
+      int val; // 節點值
+      ListNode? next; // 指向下一節點的引用
+      ListNode(this.val, [this.next]); // 建構子
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title=""
+    use std::rc::Rc;
+    use std::cell::RefCell;
+    /* 鏈結串列節點類別 */
+    #[derive(Debug)]
+    struct ListNode {
+        val: i32, // 節點值
+        next: Option<Rc<RefCell<ListNode>>>, // 指向下一節點的指標
+    }
+    ```
+
+=== "C"
+
+    ```c title=""
+    /* 鏈結串列節點結構體 */
+    typedef struct ListNode {
+        int val;               // 節點值
+        struct ListNode *next; // 指向下一節點的指標
+    } ListNode;
+
+    /* 建構子 */
+    ListNode *newListNode(int val) {
+        ListNode *node;
+        node = (ListNode *) malloc(sizeof(ListNode));
+        node->val = val;
+        node->next = NULL;
+        return node;
+    }
+    ```
+
+=== "Kotlin"
+
+    ```kotlin title=""
+    /* 鏈結串列節點類別 */
+    // 建構子
+    class ListNode(x: Int) {
+        val _val: Int = x          // 節點值
+        val next: ListNode? = null // 指向下一個節點的引用
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title=""
+    # 鏈結串列節點類別
+    class ListNode
+      attr_accessor :val  # 節點值
+      attr_accessor :next # 指向下一節點的引用
+
+      def initialize(val=0, next_node=nil)
+        @val = val
+        @next = next_node
+      end
+    end
+    ```
+
+=== "Zig"
+
+    ```zig title=""
+    // 鏈結串列節點類別
+    pub fn ListNode(comptime T: type) type {
+        return struct {
+            const Self = @This();
+
+            val: T = 0, // 節點值
+            next: ?*Self = null, // 指向下一節點的指標
+
+            // 建構子
+            pub fn init(self: *Self, x: i32) void {
+                self.val = x;
+                self.next = null;
+            }
+        };
+    }
+    ```
+
+## 鏈結串列常用操作
+
+### 初始化鏈結串列
+
+建立鏈結串列分為兩步，第一步是初始化各個節點物件，第二步是構建節點之間的引用關係。初始化完成後，我們就可以從鏈結串列的頭節點出發，透過引用指向 `next` 依次訪問所有節點。
+
+=== "Python"
+
+    ```python title="linked_list.py"
+    # 初始化鏈結串列 1 -> 3 -> 2 -> 5 -> 4
+    # 初始化各個節點
+    n0 = ListNode(1)
+    n1 = ListNode(3)
+    n2 = ListNode(2)
+    n3 = ListNode(5)
+    n4 = ListNode(4)
+    # 構建節點之間的引用
+    n0.next = n1
+    n1.next = n2
+    n2.next = n3
+    n3.next = n4
+    ```
+
+=== "C++"
+
+    ```cpp title="linked_list.cpp"
+    /* 初始化鏈結串列 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各個節點
+    ListNode* n0 = new ListNode(1);
+    ListNode* n1 = new ListNode(3);
+    ListNode* n2 = new ListNode(2);
+    ListNode* n3 = new ListNode(5);
+    ListNode* n4 = new ListNode(4);
+    // 構建節點之間的引用
+    n0->next = n1;
+    n1->next = n2;
+    n2->next = n3;
+    n3->next = n4;
+    ```
+
+=== "Java"
+
+    ```java title="linked_list.java"
+    /* 初始化鏈結串列 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各個節點
+    ListNode n0 = new ListNode(1);
+    ListNode n1 = new ListNode(3);
+    ListNode n2 = new ListNode(2);
+    ListNode n3 = new ListNode(5);
+    ListNode n4 = new ListNode(4);
+    // 構建節點之間的引用
+    n0.next = n1;
+    n1.next = n2;
+    n2.next = n3;
+    n3.next = n4;
+    ```
+
+=== "C#"
+
+    ```csharp title="linked_list.cs"
+    /* 初始化鏈結串列 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各個節點
+    ListNode n0 = new(1);
+    ListNode n1 = new(3);
+    ListNode n2 = new(2);
+    ListNode n3 = new(5);
+    ListNode n4 = new(4);
+    // 構建節點之間的引用
+    n0.next = n1;
+    n1.next = n2;
+    n2.next = n3;
+    n3.next = n4;
+    ```
+
+=== "Go"
+
+    ```go title="linked_list.go"
+    /* 初始化鏈結串列 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各個節點
+    n0 := NewListNode(1)
+    n1 := NewListNode(3)
+    n2 := NewListNode(2)
+    n3 := NewListNode(5)
+    n4 := NewListNode(4)
+    // 構建節點之間的引用
+    n0.Next = n1
+    n1.Next = n2
+    n2.Next = n3
+    n3.Next = n4
+    ```
+
+=== "Swift"
+
+    ```swift title="linked_list.swift"
+    /* 初始化鏈結串列 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各個節點
+    let n0 = ListNode(x: 1)
+    let n1 = ListNode(x: 3)
+    let n2 = ListNode(x: 2)
+    let n3 = ListNode(x: 5)
+    let n4 = ListNode(x: 4)
+    // 構建節點之間的引用
+    n0.next = n1
+    n1.next = n2
+    n2.next = n3
+    n3.next = n4
+    ```
+
+=== "JS"
+
+    ```javascript title="linked_list.js"
+    /* 初始化鏈結串列 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各個節點
+    const n0 = new ListNode(1);
+    const n1 = new ListNode(3);
+    const n2 = new ListNode(2);
+    const n3 = new ListNode(5);
+    const n4 = new ListNode(4);
+    // 構建節點之間的引用
+    n0.next = n1;
+    n1.next = n2;
+    n2.next = n3;
+    n3.next = n4;
+    ```
+
+=== "TS"
+
+    ```typescript title="linked_list.ts"
+    /* 初始化鏈結串列 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各個節點
+    const n0 = new ListNode(1);
+    const n1 = new ListNode(3);
+    const n2 = new ListNode(2);
+    const n3 = new ListNode(5);
+    const n4 = new ListNode(4);
+    // 構建節點之間的引用
+    n0.next = n1;
+    n1.next = n2;
+    n2.next = n3;
+    n3.next = n4;
+    ```
+
+=== "Dart"
+
+    ```dart title="linked_list.dart"
+    /* 初始化鏈結串列 1 -> 3 -> 2 -> 5 -> 4 */\
+    // 初始化各個節點
+    ListNode n0 = ListNode(1);
+    ListNode n1 = ListNode(3);
+    ListNode n2 = ListNode(2);
+    ListNode n3 = ListNode(5);
+    ListNode n4 = ListNode(4);
+    // 構建節點之間的引用
+    n0.next = n1;
+    n1.next = n2;
+    n2.next = n3;
+    n3.next = n4;
+    ```
+
+=== "Rust"
+
+    ```rust title="linked_list.rs"
+    /* 初始化鏈結串列 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各個節點
+    let n0 = Rc::new(RefCell::new(ListNode { val: 1, next: None }));
+    let n1 = Rc::new(RefCell::new(ListNode { val: 3, next: None }));
+    let n2 = Rc::new(RefCell::new(ListNode { val: 2, next: None }));
+    let n3 = Rc::new(RefCell::new(ListNode { val: 5, next: None }));
+    let n4 = Rc::new(RefCell::new(ListNode { val: 4, next: None }));
+
+    // 構建節點之間的引用
+    n0.borrow_mut().next = Some(n1.clone());
+    n1.borrow_mut().next = Some(n2.clone());
+    n2.borrow_mut().next = Some(n3.clone());
+    n3.borrow_mut().next = Some(n4.clone());
+    ```
+
+=== "C"
+
+    ```c title="linked_list.c"
+    /* 初始化鏈結串列 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各個節點
+    ListNode* n0 = newListNode(1);
+    ListNode* n1 = newListNode(3);
+    ListNode* n2 = newListNode(2);
+    ListNode* n3 = newListNode(5);
+    ListNode* n4 = newListNode(4);
+    // 構建節點之間的引用
+    n0->next = n1;
+    n1->next = n2;
+    n2->next = n3;
+    n3->next = n4;
+    ```
+
+=== "Kotlin"
+
+    ```kotlin title="linked_list.kt"
+    /* 初始化鏈結串列 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各個節點
+    val n0 = ListNode(1)
+    val n1 = ListNode(3)
+    val n2 = ListNode(2)
+    val n3 = ListNode(5)
+    val n4 = ListNode(4)
+    // 構建節點之間的引用
+    n0.next = n1;
+    n1.next = n2;
+    n2.next = n3;
+    n3.next = n4;
+    ```
+
+=== "Ruby"
+
+    ```ruby title="linked_list.rb"
+    # 初始化鏈結串列 1 -> 3 -> 2 -> 5 -> 4
+    # 初始化各個節點
+    n0 = ListNode.new(1)
+    n1 = ListNode.new(3)
+    n2 = ListNode.new(2)
+    n3 = ListNode.new(5)
+    n4 = ListNode.new(4)
+    # 構建節點之間的引用
+    n0.next = n1
+    n1.next = n2
+    n2.next = n3
+    n3.next = n4
+    ```
+
+=== "Zig"
+
+    ```zig title="linked_list.zig"
+    // 初始化鏈結串列
+    // 初始化各個節點
+    var n0 = inc.ListNode(i32){.val = 1};
+    var n1 = inc.ListNode(i32){.val = 3};
+    var n2 = inc.ListNode(i32){.val = 2};
+    var n3 = inc.ListNode(i32){.val = 5};
+    var n4 = inc.ListNode(i32){.val = 4};
+    // 構建節點之間的引用
+    n0.next = &n1;
+    n1.next = &n2;
+    n2.next = &n3;
+    n3.next = &n4;
+    ```
+
+??? pythontutor "視覺化執行"
+
+    https://pythontutor.com/render.html#code=class%20ListNode%3A%0A%20%20%20%20%22%22%22%E9%93%BE%E8%A1%A8%E8%8A%82%E7%82%B9%E7%B1%BB%22%22%22%0A%20%20%20%20def%20__init__%28self,%20val%3A%20int%29%3A%0A%20%20%20%20%20%20%20%20self.val%3A%20int%20%3D%20val%20%20%23%20%E8%8A%82%E7%82%B9%E5%80%BC%0A%20%20%20%20%20%20%20%20self.next%3A%20ListNode%20%7C%20None%20%3D%20None%20%20%23%20%E5%90%8E%E7%BB%A7%E8%8A%82%E7%82%B9%E5%BC%95%E7%94%A8%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%93%BE%E8%A1%A8%201%20-%3E%203%20-%3E%202%20-%3E%205%20-%3E%204%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%90%84%E4%B8%AA%E8%8A%82%E7%82%B9%0A%20%20%20%20n0%20%3D%20ListNode%281%29%0A%20%20%20%20n1%20%3D%20ListNode%283%29%0A%20%20%20%20n2%20%3D%20ListNode%282%29%0A%20%20%20%20n3%20%3D%20ListNode%285%29%0A%20%20%20%20n4%20%3D%20ListNode%284%29%0A%20%20%20%20%23%20%E6%9E%84%E5%BB%BA%E8%8A%82%E7%82%B9%E4%B9%8B%E9%97%B4%E7%9A%84%E5%BC%95%E7%94%A8%0A%20%20%20%20n0.next%20%3D%20n1%0A%20%20%20%20n1.next%20%3D%20n2%0A%20%20%20%20n2.next%20%3D%20n3%0A%20%20%20%20n3.next%20%3D%20n4&cumulative=false&curInstr=3&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false
+
+陣列整體是一個變數，比如陣列 `nums` 包含元素 `nums[0]` 和 `nums[1]` 等，而鏈結串列是由多個獨立的節點物件組成的。**我們通常將頭節點當作鏈結串列的代稱**，比如以上程式碼中的鏈結串列可記作鏈結串列 `n0` 。
+
+### 插入節點
+
+在鏈結串列中插入節點非常容易。如下圖所示，假設我們想在相鄰的兩個節點 `n0` 和 `n1` 之間插入一個新節點 `P` ，**則只需改變兩個節點引用（指標）即可**，時間複雜度為 $O(1)$ 。
+
+相比之下，在陣列中插入元素的時間複雜度為 $O(n)$ ，在大資料量下的效率較低。
+
+![鏈結串列插入節點示例](linked_list.assets/linkedlist_insert_node.png)
+
+```src
+[file]{linked_list}-[class]{}-[func]{insert}
+```
+
+### 刪除節點
+
+如下圖所示，在鏈結串列中刪除節點也非常方便，**只需改變一個節點的引用（指標）即可**。
+
+請注意，儘管在刪除操作完成後節點 `P` 仍然指向 `n1` ，但實際上走訪此鏈結串列已經無法訪問到 `P` ，這意味著 `P` 已經不再屬於該鏈結串列了。
+
+![鏈結串列刪除節點](linked_list.assets/linkedlist_remove_node.png)
+
+```src
+[file]{linked_list}-[class]{}-[func]{remove}
+```
+
+### 訪問節點
+
+**在鏈結串列中訪問節點的效率較低**。如上一節所述，我們可以在 $O(1)$ 時間下訪問陣列中的任意元素。鏈結串列則不然，程式需要從頭節點出發，逐個向後走訪，直至找到目標節點。也就是說，訪問鏈結串列的第 $i$ 個節點需要迴圈 $i - 1$ 輪，時間複雜度為 $O(n)$ 。
+
+```src
+[file]{linked_list}-[class]{}-[func]{access}
+```
+
+### 查詢節點
+
+走訪鏈結串列，查詢其中值為 `target` 的節點，輸出該節點在鏈結串列中的索引。此過程也屬於線性查詢。程式碼如下所示：
+
+```src
+[file]{linked_list}-[class]{}-[func]{find}
+```
+
+## 陣列 vs. 鏈結串列
+
+下表總結了陣列和鏈結串列的各項特點並對比了操作效率。由於它們採用兩種相反的儲存策略，因此各種性質和操作效率也呈現對立的特點。
+
+<p align="center"> 表 <id> &nbsp; 陣列與鏈結串列的效率對比 </p>
+
+|          | 陣列                           | 鏈結串列           |
+| -------- | ------------------------------ | -------------- |
+| 儲存方式 | 連續記憶體空間                   | 分散記憶體空間   |
+| 容量擴展 | 長度不可變                     | 可靈活擴展     |
+| 記憶體效率 | 元素佔用記憶體少、但可能浪費空間 | 元素佔用記憶體多 |
+| 訪問元素 | $O(1)$                         | $O(n)$         |
+| 新增元素 | $O(n)$                         | $O(1)$         |
+| 刪除元素 | $O(n)$                         | $O(1)$         |
+
+## 常見鏈結串列型別
+
+如下圖所示，常見的鏈結串列型別包括三種。
+
+- **單向鏈結串列**：即前面介紹的普通鏈結串列。單向鏈結串列的節點包含值和指向下一節點的引用兩項資料。我們將首個節點稱為頭節點，將最後一個節點稱為尾節點，尾節點指向空 `None` 。
+- **環形鏈結串列**：如果我們令單向鏈結串列的尾節點指向頭節點（首尾相接），則得到一個環形鏈結串列。在環形鏈結串列中，任意節點都可以視作頭節點。
+- **雙向鏈結串列**：與單向鏈結串列相比，雙向鏈結串列記錄了兩個方向的引用。雙向鏈結串列的節點定義同時包含指向後繼節點（下一個節點）和前驅節點（上一個節點）的引用（指標）。相較於單向鏈結串列，雙向鏈結串列更具靈活性，可以朝兩個方向走訪鏈結串列，但相應地也需要佔用更多的記憶體空間。
+
+=== "Python"
+
+    ```python title=""
+    class ListNode:
+        """雙向鏈結串列節點類別"""
+        def __init__(self, val: int):
+            self.val: int = val                # 節點值
+            self.next: ListNode | None = None  # 指向後繼節點的引用
+            self.prev: ListNode | None = None  # 指向前驅節點的引用
+    ```
+
+=== "C++"
+
+    ```cpp title=""
+    /* 雙向鏈結串列節點結構體 */
+    struct ListNode {
+        int val;         // 節點值
+        ListNode *next;  // 指向後繼節點的指標
+        ListNode *prev;  // 指向前驅節點的指標
+        ListNode(int x) : val(x), next(nullptr), prev(nullptr) {}  // 建構子
+    };
+    ```
+
+=== "Java"
+
+    ```java title=""
+    /* 雙向鏈結串列節點類別 */
+    class ListNode {
+        int val;        // 節點值
+        ListNode next;  // 指向後繼節點的引用
+        ListNode prev;  // 指向前驅節點的引用
+        ListNode(int x) { val = x; }  // 建構子
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title=""
+    /* 雙向鏈結串列節點類別 */
+    class ListNode(int x) {  // 建構子
+        int val = x;    // 節點值
+        ListNode next;  // 指向後繼節點的引用
+        ListNode prev;  // 指向前驅節點的引用
+    }
+    ```
+
+=== "Go"
+
+    ```go title=""
+    /* 雙向鏈結串列節點結構體 */
+    type DoublyListNode struct {
+        Val  int             // 節點值
+        Next *DoublyListNode // 指向後繼節點的指標
+        Prev *DoublyListNode // 指向前驅節點的指標
+    }
+
+    // NewDoublyListNode 初始化
+    func NewDoublyListNode(val int) *DoublyListNode {
+        return &DoublyListNode{
+            Val:  val,
+            Next: nil,
+            Prev: nil,
+        }
+    }
+    ```
+
+=== "Swift"
+
+    ```swift title=""
+    /* 雙向鏈結串列節點類別 */
+    class ListNode {
+        var val: Int // 節點值
+        var next: ListNode? // 指向後繼節點的引用
+        var prev: ListNode? // 指向前驅節點的引用
+
+        init(x: Int) { // 建構子
+            val = x
+        }
+    }
+    ```
+
+=== "JS"
+
+    ```javascript title=""
+    /* 雙向鏈結串列節點類別 */
+    class ListNode {
+        constructor(val, next, prev) {
+            this.val = val  ===  undefined ? 0 : val;        // 節點值
+            this.next = next  ===  undefined ? null : next;  // 指向後繼節點的引用
+            this.prev = prev  ===  undefined ? null : prev;  // 指向前驅節點的引用
+        }
+    }
+    ```
+
+=== "TS"
+
+    ```typescript title=""
+    /* 雙向鏈結串列節點類別 */
+    class ListNode {
+        val: number;
+        next: ListNode | null;
+        prev: ListNode | null;
+        constructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {
+            this.val = val  ===  undefined ? 0 : val;        // 節點值
+            this.next = next  ===  undefined ? null : next;  // 指向後繼節點的引用
+            this.prev = prev  ===  undefined ? null : prev;  // 指向前驅節點的引用
+        }
+    }
+    ```
+
+=== "Dart"
+
+    ```dart title=""
+    /* 雙向鏈結串列節點類別 */
+    class ListNode {
+        int val;        // 節點值
+        ListNode next;  // 指向後繼節點的引用
+        ListNode prev;  // 指向前驅節點的引用
+        ListNode(this.val, [this.next, this.prev]);  // 建構子
+    }
+    ```
+
+=== "Rust"
+
+    ```rust title=""
+    use std::rc::Rc;
+    use std::cell::RefCell;
+
+    /* 雙向鏈結串列節點型別 */
+    #[derive(Debug)]
+    struct ListNode {
+        val: i32, // 節點值
+        next: Option<Rc<RefCell<ListNode>>>, // 指向後繼節點的指標
+        prev: Option<Rc<RefCell<ListNode>>>, // 指向前驅節點的指標
+    }
+
+    /* 建構子 */
+    impl ListNode {
+        fn new(val: i32) -> Self {
+            ListNode {
+                val,
+                next: None,
+                prev: None,
+            }
+        }
+    }
+    ```
+
+=== "C"
+
+    ```c title=""
+    /* 雙向鏈結串列節點結構體 */
+    typedef struct ListNode {
+        int val;               // 節點值
+        struct ListNode *next; // 指向後繼節點的指標
+        struct ListNode *prev; // 指向前驅節點的指標
+    } ListNode;
+
+    /* 建構子 */
+    ListNode *newListNode(int val) {
+        ListNode *node;
+        node = (ListNode *) malloc(sizeof(ListNode));
+        node->val = val;
+        node->next = NULL;
+        node->prev = NULL;
+        return node;
+    }
+    ```
+
+=== "Kotlin"
+
+    ```kotlin title=""
+    /* 雙向鏈結串列節點類別 */
+    // 建構子
+    class ListNode(x: Int) {
+        val _val: Int = x           // 節點值
+        val next: ListNode? = null  // 指向後繼節點的引用
+        val prev: ListNode? = null  // 指向前驅節點的引用
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title=""
+    # 雙向鏈結串列節點類別
+    class ListNode
+      attr_accessor :val    # 節點值
+      attr_accessor :next   # 指向後繼節點的引用
+      attr_accessor :prev   # 指向前驅節點的引用
+
+      def initialize(val=0, next_node=nil, prev_node=nil)
+        @val = val
+        @next = next_node
+        @prev = prev_node
+      end
+    end
+    ```
+
+=== "Zig"
+
+    ```zig title=""
+    // 雙向鏈結串列節點類別
+    pub fn ListNode(comptime T: type) type {
+        return struct {
+            const Self = @This();
+
+            val: T = 0, // 節點值
+            next: ?*Self = null, // 指向後繼節點的指標
+            prev: ?*Self = null, // 指向前驅節點的指標
+
+            // 建構子
+            pub fn init(self: *Self, x: i32) void {
+                self.val = x;
+                self.next = null;
+                self.prev = null;
+            }
+        };
+    }
+    ```
+
+![常見鏈結串列種類](linked_list.assets/linkedlist_common_types.png)
+
+## 鏈結串列典型應用
+
+單向鏈結串列通常用於實現堆疊、佇列、雜湊表和圖等資料結構。
+
+- **堆疊與佇列**：當插入和刪除操作都在鏈結串列的一端進行時，它表現出先進後出的特性，對應堆疊；當插入操作在鏈結串列的一端進行，刪除操作在鏈結串列的另一端進行，它表現出先進先出的特性，對應佇列。
+- **雜湊表**：鏈式位址是解決雜湊衝突的主流方案之一，在該方案中，所有衝突的元素都會被放到一個鏈結串列中。
+- **圖**：鄰接表是表示圖的一種常用方式，其中圖的每個頂點都與一個鏈結串列相關聯，鏈結串列中的每個元素都代表與該頂點相連的其他頂點。
+
+雙向鏈結串列常用於需要快速查詢前一個和後一個元素的場景。
+
+- **高階資料結構**：比如在紅黑樹、B 樹中，我們需要訪問節點的父節點，這可以透過在節點中儲存一個指向父節點的引用來實現，類似於雙向鏈結串列。
+- **瀏覽器歷史**：在網頁瀏覽器中，當用戶點選前進或後退按鈕時，瀏覽器需要知道使用者訪問過的前一個和後一個網頁。雙向鏈結串列的特性使得這種操作變得簡單。
+- **LRU 演算法**：在快取淘汰（LRU）演算法中，我們需要快速找到最近最少使用的資料，以及支持快速新增和刪除節點。這時候使用雙向鏈結串列就非常合適。
+
+環形鏈結串列常用於需要週期性操作的場景，比如作業系統的資源排程。
+
+- **時間片輪轉排程演算法**：在作業系統中，時間片輪轉排程演算法是一種常見的 CPU 排程演算法，它需要對一組程序進行迴圈。每個程序被賦予一個時間片，當時間片用完時，CPU 將切換到下一個程序。這種迴圈操作可以透過環形鏈結串列來實現。
+- **資料緩衝區**：在某些資料緩衝區的實現中，也可能會使用環形鏈結串列。比如在音訊、影片播放器中，資料流可能會被分成多個緩衝塊並放入一個環形鏈結串列，以便實現無縫播放。

zh-hant/docs/chapter_array_and_linkedlist/ram_and_cache.md

@@ -0,0 +1,71 @@
+# 記憶體與快取 *
+
+在本章的前兩節中，我們探討了陣列和鏈結串列這兩種基礎且重要的資料結構，它們分別代表了“連續儲存”和“分散儲存”兩種物理結構。
+
+實際上，**物理結構在很大程度上決定了程式對記憶體和快取的使用效率**，進而影響演算法程式的整體效能。
+
+## 計算機儲存裝置
+
+計算機中包括三種類型的儲存裝置：<u>硬碟（hard disk）</u>、<u>記憶體（random-access memory, RAM）</u>、<u>快取（cache memory）</u>。下表展示了它們在計算機系統中的不同角色和效能特點。
+
+<p align="center"> 表 <id> &nbsp; 計算機的儲存裝置 </p>
+
+|        | 硬碟                                     | 記憶體                                   | 快取                                              |
+| ------ | ---------------------------------------- | -------------------------------------- | ------------------------------------------------- |
+| 用途   | 長期儲存資料，包括作業系統、程式、檔案等 | 臨時儲存當前執行的程式和正在處理的資料 | 儲存經常訪問的資料和指令，減少 CPU 訪問記憶體的次數 |
+| 易失性 | 斷電後資料不會丟失                       | 斷電後資料會丟失                       | 斷電後資料會丟失                                  |
+| 容量   | 較大，TB 級別                            | 較小，GB 級別                          | 非常小，MB 級別                                   |
+| 速度   | 較慢，幾百到幾千 MB/s                    | 較快，幾十 GB/s                        | 非常快，幾十到幾百 GB/s                           |
+| 價格   | 較便宜，幾毛到幾元 / GB                  | 較貴，幾十到幾百元 / GB                | 非常貴，隨 CPU 打包計價                           |
+
+我們可以將計算機儲存系統想象為下圖所示的金字塔結構。越靠近金字塔頂端的儲存裝置的速度越快、容量越小、成本越高。這種多層級的設計並非偶然，而是計算機科學家和工程師們經過深思熟慮的結果。
+
+- **硬碟難以被記憶體取代**。首先，記憶體中的資料在斷電後會丟失，因此它不適合長期儲存資料；其次，記憶體的成本是硬碟的幾十倍，這使得它難以在消費者市場普及。
+- **快取的大容量和高速度難以兼得**。隨著 L1、L2、L3 快取的容量逐步增大，其物理尺寸會變大，與 CPU 核心之間的物理距離會變遠，從而導致資料傳輸時間增加，元素訪問延遲變高。在當前技術下，多層級的快取結構是容量、速度和成本之間的最佳平衡點。
+
+![計算機儲存系統](ram_and_cache.assets/storage_pyramid.png)
+
+!!! note
+
+    計算機的儲存層次結構體現了速度、容量和成本三者之間的精妙平衡。實際上，這種權衡普遍存在於所有工業領域，它要求我們在不同的優勢和限制之間找到最佳平衡點。
+
+總的來說，**硬碟用於長期儲存大量資料，記憶體用於臨時儲存程式執行中正在處理的資料，而快取則用於儲存經常訪問的資料和指令**，以提高程式執行效率。三者共同協作，確保計算機系統高效執行。
+
+如下圖所示，在程式執行時，資料會從硬碟中被讀取到記憶體中，供 CPU 計算使用。快取可以看作 CPU 的一部分，**它透過智慧地從記憶體載入資料**，給 CPU 提供高速的資料讀取，從而顯著提升程式的執行效率，減少對較慢的記憶體的依賴。
+
+![硬碟、記憶體和快取之間的資料流通](ram_and_cache.assets/computer_storage_devices.png)
+
+## 資料結構的記憶體效率
+
+在記憶體空間利用方面，陣列和鏈結串列各自具有優勢和侷限性。
+
+一方面，**記憶體是有限的，且同一塊記憶體不能被多個程式共享**，因此我們希望資料結構能夠儘可能高效地利用空間。陣列的元素緊密排列，不需要額外的空間來儲存鏈結串列節點間的引用（指標），因此空間效率更高。然而，陣列需要一次性分配足夠的連續記憶體空間，這可能導致記憶體浪費，陣列擴容也需要額外的時間和空間成本。相比之下，鏈結串列以“節點”為單位進行動態記憶體分配和回收，提供了更大的靈活性。
+
+另一方面，在程式執行時，**隨著反覆申請與釋放記憶體，空閒記憶體的碎片化程度會越來越高**，從而導致記憶體的利用效率降低。陣列由於其連續的儲存方式，相對不容易導致記憶體碎片化。相反，鏈結串列的元素是分散儲存的，在頻繁的插入與刪除操作中，更容易導致記憶體碎片化。
+
+## 資料結構的快取效率
+
+快取雖然在空間容量上遠小於記憶體，但它比記憶體快得多，在程式執行速度上起著至關重要的作用。由於快取的容量有限，只能儲存一小部分頻繁訪問的資料，因此當 CPU 嘗試訪問的資料不在快取中時，就會發生<u>快取未命中（cache miss）</u>，此時 CPU 不得不從速度較慢的記憶體中載入所需資料。
+
+顯然，**“快取未命中”越少，CPU 讀寫資料的效率就越高**，程式效能也就越好。我們將 CPU 從快取中成功獲取資料的比例稱為<u>快取命中率（cache hit rate）</u>，這個指標通常用來衡量快取效率。
+
+為了儘可能達到更高的效率，快取會採取以下資料載入機制。
+
+- **快取行**：快取不是單個位元組地儲存與載入資料，而是以快取行為單位。相比於單個位元組的傳輸，快取行的傳輸形式更加高效。
+- **預取機制**：處理器會嘗試預測資料訪問模式（例如順序訪問、固定步長跳躍訪問等），並根據特定模式將資料載入至快取之中，從而提升命中率。
+- **空間區域性**：如果一個數據被訪問，那麼它附近的資料可能近期也會被訪問。因此，快取在載入某一資料時，也會載入其附近的資料，以提高命中率。
+- **時間區域性**：如果一個數據被訪問，那麼它在不久的將來很可能再次被訪問。快取利用這一原理，透過保留最近訪問過的資料來提高命中率。
+
+實際上，**陣列和鏈結串列對快取的利用效率是不同的**，主要體現在以下幾個方面。
+
+- **佔用空間**：鏈結串列元素比陣列元素佔用空間更多，導致快取中容納的有效資料量更少。
+- **快取行**：鏈結串列資料分散在記憶體各處，而快取是“按行載入”的，因此載入到無效資料的比例更高。
+- **預取機制**：陣列比鏈結串列的資料訪問模式更具“可預測性”，即系統更容易猜出即將被載入的資料。
+- **空間區域性**：陣列被儲存在集中的記憶體空間中，因此被載入資料附近的資料更有可能即將被訪問。
+
+總體而言，**陣列具有更高的快取命中率，因此它在操作效率上通常優於鏈結串列**。這使得在解決演算法問題時，基於陣列實現的資料結構往往更受歡迎。
+
+需要注意的是，**高快取效率並不意味著陣列在所有情況下都優於鏈結串列**。實際應用中選擇哪種資料結構，應根據具體需求來決定。例如，陣列和鏈結串列都可以實現“堆疊”資料結構（下一章會詳細介紹），但它們適用於不同場景。
+
+- 在做演算法題時，我們會傾向於選擇基於陣列實現的堆疊，因為它提供了更高的操作效率和隨機訪問的能力，代價僅是需要預先為陣列分配一定的記憶體空間。
+- 如果資料量非常大、動態性很高、堆疊的預期大小難以估計，那麼基於鏈結串列實現的堆疊更加合適。鏈結串列能夠將大量資料分散儲存於記憶體的不同部分，並且避免了陣列擴容產生的額外開銷。

zh-hant/docs/chapter_array_and_linkedlist/summary.md

@@ -0,0 +1,76 @@
+# 小結
+
+### 重點回顧
+
+- 陣列和鏈結串列是兩種基本的資料結構，分別代表資料在計算機記憶體中的兩種儲存方式：連續空間儲存和分散空間儲存。兩者的特點呈現出互補的特性。
+- 陣列支持隨機訪問、佔用記憶體較少；但插入和刪除元素效率低，且初始化後長度不可變。
+- 鏈結串列透過更改引用（指標）實現高效的節點插入與刪除，且可以靈活調整長度；但節點訪問效率低、佔用記憶體較多。常見的鏈結串列型別包括單向鏈結串列、環形鏈結串列、雙向鏈結串列。
+- 串列是一種支持增刪查改的元素有序集合，通常基於動態陣列實現。它保留了陣列的優勢，同時可以靈活調整長度。
+- 串列的出現大幅提高了陣列的實用性，但可能導致部分記憶體空間浪費。
+- 程式執行時，資料主要儲存在記憶體中。陣列可提供更高的記憶體空間效率，而鏈結串列則在記憶體使用上更加靈活。
+- 快取透過快取行、預取機制以及空間區域性和時間區域性等資料載入機制，為 CPU 提供快速資料訪問，顯著提升程式的執行效率。
+- 由於陣列具有更高的快取命中率，因此它通常比鏈結串列更高效。在選擇資料結構時，應根據具體需求和場景做出恰當選擇。
+
+### Q & A
+
+**Q**：陣列儲存在堆疊上和儲存在堆積上，對時間效率和空間效率是否有影響？
+
+儲存在堆疊上和堆積上的陣列都被儲存在連續記憶體空間內，資料操作效率基本一致。然而，堆疊和堆積具有各自的特點，從而導致以下不同點。
+
+1. 分配和釋放效率：堆疊是一塊較小的記憶體，分配由編譯器自動完成；而堆積記憶體相對更大，可以在程式碼中動態分配，更容易碎片化。因此，堆積上的分配和釋放操作通常比堆疊上的慢。
+2. 大小限制：堆疊記憶體相對較小，堆積的大小一般受限於可用記憶體。因此堆積更加適合儲存大型陣列。
+3. 靈活性：堆疊上的陣列的大小需要在編譯時確定，而堆積上的陣列的大小可以在執行時動態確定。
+
+**Q**：為什麼陣列要求相同型別的元素，而在鏈結串列中卻沒有強調相同型別呢？
+
+鏈結串列由節點組成，節點之間透過引用（指標）連線，各個節點可以儲存不同型別的資料，例如 `int`、`double`、`string`、`object` 等。
+
+相對地，陣列元素則必須是相同型別的，這樣才能透過計算偏移量來獲取對應元素位置。例如，陣列同時包含 `int` 和 `long` 兩種型別，單個元素分別佔用 4 位元組 和 8 位元組 ，此時就不能用以下公式計算偏移量了，因為陣列中包含了兩種“元素長度”。
+
+```shell
+# 元素記憶體位址 = 陣列記憶體位址（首元素記憶體位址） + 元素長度 * 元素索引
+```
+
+**Q**：刪除節點 `P` 後，是否需要把 `P.next` 設為 `None` 呢？
+
+不修改 `P.next` 也可以。從該鏈結串列的角度看，從頭節點走訪到尾節點已經不會遇到 `P` 了。這意味著節點 `P` 已經從鏈結串列中刪除了，此時節點 `P` 指向哪裡都不會對該鏈結串列產生影響。
+
+從資料結構與演算法（做題）的角度看，不斷開沒有關係，只要保證程式的邏輯是正確的就行。從標準庫的角度看，斷開更加安全、邏輯更加清晰。如果不斷開，假設被刪除節點未被正常回收，那麼它會影響後繼節點的記憶體回收。
+
+**Q**：在鏈結串列中插入和刪除操作的時間複雜度是 $O(1)$ 。但是增刪之前都需要 $O(n)$ 的時間查詢元素，那為什麼時間複雜度不是 $O(n)$ 呢？
+
+如果是先查詢元素、再刪除元素，時間複雜度確實是 $O(n)$ 。然而，鏈結串列的 $O(1)$ 增刪的優勢可以在其他應用上得到體現。例如，雙向佇列適合使用鏈結串列實現，我們維護一個指標變數始終指向頭節點、尾節點，每次插入與刪除操作都是 $O(1)$ 。
+
+**Q**：圖“鏈結串列定義與儲存方式”中，淺藍色的儲存節點指標是佔用一塊記憶體位址嗎？還是和節點值各佔一半呢？
+
+該示意圖只是定性表示，定量表示需要根據具體情況進行分析。
+
+- 不同型別的節點值佔用的空間是不同的，比如 `int`、`long`、`double` 和例項物件等。
+- 指標變數佔用的記憶體空間大小根據所使用的作業系統及編譯環境而定，大多為 8 位元組或 4 位元組。
+
+**Q**：在串列末尾新增元素是否時時刻刻都為 $O(1)$ ？
+
+如果新增元素時超出串列長度，則需要先擴容串列再新增。系統會申請一塊新的記憶體，並將原串列的所有元素搬運過去，這時候時間複雜度就會是 $O(n)$ 。
+
+**Q**：“串列的出現極大地提高了陣列的實用性，但可能導致部分記憶體空間浪費”，這裡的空間浪費是指額外增加的變數如容量、長度、擴容倍數所佔的記憶體嗎？
+
+這裡的空間浪費主要有兩方面含義：一方面，串列都會設定一個初始長度，我們不一定需要用這麼多；另一方面，為了防止頻繁擴容，擴容一般會乘以一個係數，比如 $\times 1.5$ 。這樣一來，也會出現很多空位，我們通常不能完全填滿它們。
+
+**Q**：在 Python 中初始化 `n = [1, 2, 3]` 後，這 3 個元素的位址是相連的，但是初始化 `m = [2, 1, 3]` 會發現它們每個元素的 id 並不是連續的，而是分別跟 `n` 中的相同。這些元素的位址不連續，那麼 `m` 還是陣列嗎？
+
+假如把串列元素換成鏈結串列節點 `n = [n1, n2, n3, n4, n5]` ，通常情況下這 5 個節點物件也分散儲存在記憶體各處。然而，給定一個串列索引，我們仍然可以在 $O(1)$ 時間內獲取節點記憶體位址，從而訪問到對應的節點。這是因為陣列中儲存的是節點的引用，而非節點本身。
+
+與許多語言不同，Python 中的數字也被包裝為物件，串列中儲存的不是數字本身，而是對數字的引用。因此，我們會發現兩個陣列中的相同數字擁有同一個 id ，並且這些數字的記憶體位址無須連續。
+
+**Q**：C++ STL 裡面的 `std::list` 已經實現了雙向鏈結串列，但好像一些演算法書上不怎麼直接使用它，是不是因為有什麼侷限性呢？
+
+一方面，我們往往更青睞使用陣列實現演算法，而只在必要時才使用鏈結串列，主要有兩個原因。
+
+- 空間開銷：由於每個元素需要兩個額外的指標（一個用於前一個元素，一個用於後一個元素），所以 `std::list` 通常比 `std::vector` 更佔用空間。
+- 快取不友好：由於資料不是連續存放的，因此 `std::list` 對快取的利用率較低。一般情況下，`std::vector` 的效能會更好。
+
+另一方面，必要使用鏈結串列的情況主要是二元樹和圖。堆疊和佇列往往會使用程式語言提供的 `stack` 和 `queue` ，而非鏈結串列。
+
+**Q**：初始化串列 `res = [0] * self.size()` 操作，會導致 `res` 的每個元素引用相同的位址嗎？
+
+不會。但二維陣列會有這個問題，例如初始化二維串列 `res = [[0] * self.size()]` ，則多次引用了同一個串列 `[0]` 。