diff --git a/build/chapter_array_and_linkedlist/array.md b/build/chapter_array_and_linkedlist/array.md
index fa4418ee8..c4f0d920d 100755
--- a/build/chapter_array_and_linkedlist/array.md
+++ b/build/chapter_array_and_linkedlist/array.md
@@ -122,6 +122,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
         // 在区间 [0, nums.length) 中随机抽取一个数字
         int randomIndex = ThreadLocalRandom.current().
                           nextInt(0, nums.length);
+        // 获取并返回随机元素
         int randomNum = nums[randomIndex];
         return randomNum;
     }
@@ -417,7 +418,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
         // 将 num 赋给 index 处元素
         nums[index] = num;
     }
-    
+
     /* 删除索引 index 处元素 */
     void remove(int[] nums, int index) {
         // 把索引 index 之后的所有元素向前移动一位
diff --git a/build/chapter_array_and_linkedlist/linked_list.md b/build/chapter_array_and_linkedlist/linked_list.md
index 0e17954a5..271b0dcc7 100755
--- a/build/chapter_array_and_linkedlist/linked_list.md
+++ b/build/chapter_array_and_linkedlist/linked_list.md
@@ -331,7 +331,7 @@ comments: true
         n0.next = P;
         P.next = n1;
     }
-    
+
     /* 删除链表的结点 n0 之后的首个结点 */
     void remove(ListNode n0) {
         if (n0.next == null)
diff --git a/build/chapter_array_and_linkedlist/list.md b/build/chapter_array_and_linkedlist/list.md
index 5887e6f3f..76c521435 100755
--- a/build/chapter_array_and_linkedlist/list.md
+++ b/build/chapter_array_and_linkedlist/list.md
@@ -801,6 +801,17 @@ comments: true
             // 更新列表容量
             capacity = nums.length;
         }
+
+        /* 将列表转换为数组 */
+        public int[] toArray() {
+            int size = size();
+            // 仅转换有效长度范围内的列表元素
+            int[] nums = new int[size];
+            for (int i = 0; i < size; i++) {
+                nums[i] = get(i);
+            }
+            return nums;
+        }
     }
     ```
 
diff --git a/build/chapter_computational_complexity/space_complexity.md b/build/chapter_computational_complexity/space_complexity.md
index 61a217f6e..1d987ac6e 100755
--- a/build/chapter_computational_complexity/space_complexity.md
+++ b/build/chapter_computational_complexity/space_complexity.md
@@ -1094,7 +1094,7 @@ $$
     /* 平方阶 */
     void quadratic(int n) {
         // 矩阵占用 O(n^2) 空间
-        int [][]numMatrix = new int[n][n];
+        int[][] numMatrix = new int[n][n];
         // 二维列表占用 O(n^2) 空间
         List<List<Integer>> numList = new ArrayList<>();
         for (int i = 0; i < n; i++) {
@@ -1253,6 +1253,7 @@ $$
         if (n <= 0) return 0;
         // 数组 nums 长度为 n, n-1, ..., 2, 1
         int[] nums = new int[n];
+        System.out.println("递归 n = " + n + " 中的 nums 长度 = " + nums.length);
         return quadraticRecur(n - 1);
     }
     ```
diff --git a/build/chapter_computational_complexity/space_time_tradeoff.md b/build/chapter_computational_complexity/space_time_tradeoff.md
index 07eea2e1a..552b8d085 100755
--- a/build/chapter_computational_complexity/space_time_tradeoff.md
+++ b/build/chapter_computational_complexity/space_time_tradeoff.md
@@ -33,6 +33,7 @@ comments: true
 === "Java"
 
     ```java title="leetcode_two_sum.java"
+    /* 方法一：暴力枚举 */
     class SolutionBruteForce {
         public int[] twoSum(int[] nums, int target) {
             int size = nums.length;
@@ -207,6 +208,7 @@ comments: true
 === "Java"
 
     ```java title="leetcode_two_sum.java"
+    /* 方法二：辅助哈希表 */
     class SolutionHashMap {
         public int[] twoSum(int[] nums, int target) {
             int size = nums.length;
diff --git a/build/chapter_computational_complexity/time_complexity.md b/build/chapter_computational_complexity/time_complexity.md
index dd8df29b2..e2883be48 100755
--- a/build/chapter_computational_complexity/time_complexity.md
+++ b/build/chapter_computational_complexity/time_complexity.md
@@ -2193,7 +2193,7 @@ $$
     /* 线性对数阶 */
     int linearLogRecur(float n) {
         if (n <= 1) return 1;
-        int count = linearLogRecur(n / 2) +
+        int count = linearLogRecur(n / 2) + 
                     linearLogRecur(n / 2);
         for (int i = 0; i < n; i++) {
             count++;
@@ -2524,34 +2524,32 @@ $$
 === "Java"
 
     ```java title="worst_best_time_complexity.java"
-    public class worst_best_time_complexity {
-        /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
-        int[] randomNumbers(int n) {
-            Integer[] nums = new Integer[n];
-            // 生成数组 nums = { 1, 2, 3, ..., n }
-            for (int i = 0; i < n; i++) {
-                nums[i] = i + 1;
-            }
-            // 随机打乱数组元素
-            Collections.shuffle(Arrays.asList(nums));
-            // Integer[] -> int[]
-            int[] res = new int[n];
-            for (int i = 0; i < n; i++) {
-                res[i] = nums[i];
-            }
-            return res;
+    /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
+    int[] randomNumbers(int n) {
+        Integer[] nums = new Integer[n];
+        // 生成数组 nums = { 1, 2, 3, ..., n }
+        for (int i = 0; i < n; i++) {
+            nums[i] = i + 1;
         }
+        // 随机打乱数组元素
+        Collections.shuffle(Arrays.asList(nums));
+        // Integer[] -> int[]
+        int[] res = new int[n];
+        for (int i = 0; i < n; i++) {
+            res[i] = nums[i];
+        }
+        return res;
+    }
 
-        /* 查找数组 nums 中数字 1 所在索引 */
-        int findOne(int[] nums) {
-            for (int i = 0; i < nums.length; i++) {
-                // 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
-                // 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
-                if (nums[i] == 1)
-                    return i;
-            }
-            return -1;
+    /* 查找数组 nums 中数字 1 所在索引 */
+    int findOne(int[] nums) {
+        for (int i = 0; i < nums.length; i++) {
+            // 当元素 1 在数组头部时，达到最佳时间复杂度 O(1)
+            // 当元素 1 在数组尾部时，达到最差时间复杂度 O(n)
+            if (nums[i] == 1)
+                return i;
         }
+        return -1;
     }
     ```
 
@@ -2640,7 +2638,7 @@ $$
     ```js title="worst_best_time_complexity.js"
     /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
     function randomNumbers(n) {
-        let nums = Array(n);
+        const nums = Array(n);
         // 生成数组 nums = { 1, 2, 3, ..., n }
         for (let i = 0; i < n; i++) {
             nums[i] = i + 1;
@@ -2673,15 +2671,15 @@ $$
     ```typescript title="worst_best_time_complexity.ts"
     /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
     function randomNumbers(n: number): number[] {
-        let nums = Array(n);
+        const nums = Array(n);
         // 生成数组 nums = { 1, 2, 3, ..., n }
         for (let i = 0; i < n; i++) {
             nums[i] = i + 1;
         }
         // 随机打乱数组元素
         for (let i = 0; i < n; i++) {
-            let r = Math.floor(Math.random() * (i + 1));
-            let temp = nums[i];
+            const r = Math.floor(Math.random() * (i + 1));
+            const temp = nums[i];
             nums[i] = nums[r];
             nums[r] = temp;
         }
diff --git a/build/chapter_graph/graph_operations.md b/build/chapter_graph/graph_operations.md
index 4b86d4d39..6800193e0 100644
--- a/build/chapter_graph/graph_operations.md
+++ b/build/chapter_graph/graph_operations.md
@@ -39,7 +39,7 @@ comments: true
     class GraphAdjMat {
         List<Integer> vertices;     // 顶点列表，元素代表“顶点值”，索引代表“顶点索引”
         List<List<Integer>> adjMat; // 邻接矩阵，行列索引对应“顶点索引”
-    
+
         /* 构造函数 */
         public GraphAdjMat(int[] vertices, int[][] edges) {
             this.vertices = new ArrayList<>();
@@ -54,12 +54,12 @@ comments: true
                 addEdge(e[0], e[1]);
             }
         }
-    
+
         /* 获取顶点数量 */
         public int size() {
             return vertices.size();
         }
-    
+
         /* 添加顶点 */
         public void addVertex(int val) {
             int n = size();
@@ -76,7 +76,7 @@ comments: true
                 row.add(0);
             }
         }
-    
+
         /* 删除顶点 */
         public void removeVertex(int index) {
             if (index >= size())
@@ -90,7 +90,7 @@ comments: true
                 row.remove(index);
             }
         }
-    
+
         /* 添加边 */
         // 参数 i, j 对应 vertices 元素索引
         public void addEdge(int i, int j) {
@@ -101,7 +101,7 @@ comments: true
             adjMat.get(i).set(j, 1);
             adjMat.get(j).set(i, 1);
         }
-    
+
         /* 删除边 */
         // 参数 i, j 对应 vertices 元素索引
         public void removeEdge(int i, int j) {
@@ -111,6 +111,14 @@ comments: true
             adjMat.get(i).set(j, 0);
             adjMat.get(j).set(i, 0);
         }
+
+        /* 打印邻接矩阵 */
+        public void print() {
+            System.out.print("顶点列表 = ");
+            System.out.println(vertices);
+            System.out.println("邻接矩阵 =");
+            PrintUtil.printMatrix(adjMat);
+        }
     }
     ```
 
@@ -364,12 +372,12 @@ comments: true
             this.val = val;
         }
     }
-    
+
     /* 基于邻接表实现的无向图类 */
     class GraphAdjList {
         // 请注意，vertices 和 adjList 中存储的都是 Vertex 对象
         Map<Vertex, Set<Vertex>> adjList; // 邻接表（使用哈希表实现）
-    
+
         /* 构造函数 */
         public GraphAdjList(Vertex[][] edges) {
             this.adjList = new HashMap<>();
@@ -380,12 +388,12 @@ comments: true
                 addEdge(edge[0], edge[1]);
             }
         }
-    
+
         /* 获取顶点数量 */
         public int size() {
             return adjList.size();
         }
-    
+
         /* 添加边 */
         public void addEdge(Vertex vet1, Vertex vet2) {
             if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)
@@ -394,7 +402,7 @@ comments: true
             adjList.get(vet1).add(vet2);
             adjList.get(vet2).add(vet1);
         }
-    
+
         /* 删除边 */
         public void removeEdge(Vertex vet1, Vertex vet2) {
             if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)
@@ -403,7 +411,7 @@ comments: true
             adjList.get(vet1).remove(vet2);
             adjList.get(vet2).remove(vet1);
         }
-    
+
         /* 添加顶点 */
         public void addVertex(Vertex vet) {
             if (adjList.containsKey(vet))
@@ -411,7 +419,7 @@ comments: true
             // 在邻接表中添加一个新链表（即 HashSet）
             adjList.put(vet, new HashSet<>());
         }
-    
+
         /* 删除顶点 */
         public void removeVertex(Vertex vet) {
             if (!adjList.containsKey(vet))
@@ -423,6 +431,17 @@ comments: true
                 set.remove(vet);
             }
         }
+
+        /* 打印邻接表 */
+        public void print() {
+            System.out.println("邻接表 =");
+            for (Map.Entry<Vertex, Set<Vertex>> entry : adjList.entrySet()) {
+                List<Integer> tmp = new ArrayList<>();
+                for (Vertex vertex : entry.getValue())
+                    tmp.add(vertex.val);
+                System.out.println(entry.getKey().val + ": " + tmp + ",");
+            }
+        }
     }
     ```
 
diff --git a/build/chapter_hashing/hash_map.md b/build/chapter_hashing/hash_map.md
index 40913ec14..4943b4440 100755
--- a/build/chapter_hashing/hash_map.md
+++ b/build/chapter_hashing/hash_map.md
@@ -418,14 +418,14 @@ $$
     ```java title="array_hash_map.java"
     /* 键值对 int->String */
     class Entry {
-        public int key;     // 键
-        public String val;  // 值
+        public int key;
+        public String val;
         public Entry(int key, String val) {
             this.key = key;
             this.val = val;
         }
     }
-    
+
     /* 基于数组简易实现的哈希表 */
     class ArrayHashMap {
         private List<Entry> bucket;
@@ -436,13 +436,13 @@ $$
                 bucket.add(null);
             }
         }
-    
+
         /* 哈希函数 */
         private int hashFunc(int key) {
             int index = key % 100;
             return index;
         }
-    
+
         /* 查询操作 */
         public String get(int key) {
             int index = hashFunc(key);
@@ -450,20 +450,57 @@ $$
             if (pair == null) return null;
             return pair.val;
         }
-    
+
         /* 添加操作 */
         public void put(int key, String val) {
             Entry pair = new Entry(key, val);
             int index = hashFunc(key);
             bucket.set(index, pair);
         }
-    
+
         /* 删除操作 */
         public void remove(int key) {
             int index = hashFunc(key);
-            // 置为 null，代表删除
+            // 置为 null ，代表删除
             bucket.set(index, null);
         }
+
+        /* 获取所有键值对 */
+        public List<Entry> entrySet() {
+            List<Entry> entrySet = new ArrayList<>();
+            for (Entry pair : bucket) {
+                if (pair != null)
+                    entrySet.add(pair);
+            }
+            return entrySet;
+        }
+
+        /* 获取所有键 */
+        public List<Integer> keySet() {
+            List<Integer> keySet = new ArrayList<>();
+            for (Entry pair : bucket) {
+                if (pair != null)
+                    keySet.add(pair.key);
+            }
+            return keySet;
+        }
+
+        /* 获取所有值 */
+        public List<String> valueSet() {
+            List<String> valueSet = new ArrayList<>();
+            for (Entry pair : bucket) {
+                if (pair != null)
+                    valueSet.add(pair.val);
+            }
+            return valueSet;
+        }
+
+        /* 打印哈希表 */
+        public void print() {
+            for (Entry kv: entrySet()) {
+                System.out.println(kv.key + " -> " + kv.val);
+            }
+        }
     }
     ```
 
diff --git a/build/chapter_heap/heap.md b/build/chapter_heap/heap.md
index 79c1ded80..efbac2365 100644
--- a/build/chapter_heap/heap.md
+++ b/build/chapter_heap/heap.md
@@ -260,24 +260,16 @@ comments: true
 === "Java"
 
     ```java title="my_heap.java"
-    // 使用列表而非数组，这样无需考虑扩容问题
-    List<Integer> maxHeap;
-    
-    /* 构造函数，建立空堆 */
-    public MaxHeap() {
-        maxHeap = new ArrayList<>();
-    }
-    
     /* 获取左子结点索引 */
     int left(int i) {
         return 2 * i + 1;
     }
-    
+
     /* 获取右子结点索引 */
     int right(int i) {
         return 2 * i + 2;
     }
-    
+
     /* 获取父结点索引 */
     int parent(int i) {
         return (i - 1) / 2; // 向下整除
@@ -408,7 +400,7 @@ comments: true
 
     ```java title="my_heap.java"
     /* 访问堆顶元素 */
-    public int peek() {
+    int peek() {
         return maxHeap.get(0);
     }
     ```
@@ -512,13 +504,13 @@ comments: true
         // 从底至顶堆化
         siftUp(size() - 1);
     }
-    
+
     /* 从结点 i 开始，从底至顶堆化 */
     void siftUp(int i) {
         while (true) {
             // 获取结点 i 的父结点
             int p = parent(i);
-            // 若“越过根结点”或“结点无需修复”，则结束堆化
+            // 当“越过根结点”或“结点无需修复”时，结束堆化
             if (p < 0 || maxHeap.get(i) <= maxHeap.get(p))
                 break;
             // 交换两结点
@@ -708,7 +700,7 @@ comments: true
         // 返回堆顶元素
         return val;
     }
-    
+
     /* 从结点 i 开始，从顶至底堆化 */
     void siftDown(int i) {
         while (true) {
@@ -718,7 +710,7 @@ comments: true
                 ma = l;
             if (r < size() && maxHeap.get(r) > maxHeap.get(ma))
                 ma = r;
-            // 若“结点 i 最大”或“越过叶结点”，则结束堆化
+            // 若结点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
             if (ma == i) break;
             // 交换两结点
             swap(i, ma);
@@ -902,7 +894,7 @@ comments: true
 
     ```java title="my_heap.java"
     /* 构造函数，根据输入列表建堆 */
-    public MaxHeap(List<Integer> nums) {
+    MaxHeap(List<Integer> nums) {
         // 将列表元素原封不动添加进堆
         maxHeap = new ArrayList<>(nums);
         // 堆化除叶结点以外的其他所有结点
diff --git a/build/chapter_sorting/merge_sort.md b/build/chapter_sorting/merge_sort.md
index cf2854917..16ea46563 100755
--- a/build/chapter_sorting/merge_sort.md
+++ b/build/chapter_sorting/merge_sort.md
@@ -62,11 +62,9 @@ comments: true
 === "Java"
 
     ```java title="merge_sort.java"
-    /**
-     * 合并左子数组和右子数组
-     * 左子数组区间 [left, mid]
-     * 右子数组区间 [mid + 1, right]
-     */
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
     void merge(int[] nums, int left, int mid, int right) {
         // 初始化辅助数组
         int[] tmp = Arrays.copyOfRange(nums, left, right + 1);   
@@ -89,16 +87,16 @@ comments: true
                 nums[k] = tmp[j++];
         }
     }
-    
+
     /* 归并排序 */
     void mergeSort(int[] nums, int left, int right) {
         // 终止条件
         if (left >= right) return;       // 当子数组长度为 1 时终止递归
-        // 递归划分
-        int mid = (left + right) / 2;    // 计算数组中点
+        // 划分阶段
+        int mid = (left + right) / 2;    // 计算中点
         mergeSort(nums, left, mid);      // 递归左子数组
         mergeSort(nums, mid + 1, right); // 递归右子数组
-        // 回溯合并
+        // 合并阶段
         merge(nums, left, mid, right);
     }
     ```
@@ -106,11 +104,9 @@ comments: true
 === "C++"
 
     ```cpp title="merge_sort.cpp"
-    /**
-     * 合并左子数组和右子数组
-     * 左子数组区间 [left, mid]
-     * 右子数组区间 [mid + 1, right]
-     */
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
     void merge(vector<int>& nums, int left, int mid, int right) {
         // 初始化辅助数组
         vector<int> tmp(nums.begin() + left, nums.begin() + right + 1);   
@@ -245,11 +241,9 @@ comments: true
 === "JavaScript"
 
     ```js title="merge_sort.js"
-    /**
-     * 合并左子数组和右子数组
-     * 左子数组区间 [left, mid]
-     * 右子数组区间 [mid + 1, right]
-     */
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
     function merge(nums, left, mid, right) {
         // 初始化辅助数组
         let tmp = nums.slice(left, right + 1);   
@@ -290,11 +284,9 @@ comments: true
 === "TypeScript"
 
     ```typescript title="merge_sort.ts"
-    /**
-     * 合并左子数组和右子数组
-     * 左子数组区间 [left, mid]
-     * 右子数组区间 [mid + 1, right]
-     */
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
     function merge(nums: number[], left: number, mid: number, right: number): void {
         // 初始化辅助数组
         let tmp = nums.slice(left, right + 1);
@@ -341,11 +333,9 @@ comments: true
 === "C#"
 
     ```csharp title="merge_sort.cs"
-    /**
-     * 合并左子数组和右子数组
-     * 左子数组区间 [left, mid]
-     * 右子数组区间 [mid + 1, right]
-     */
+    /* 合并左子数组和右子数组 */
+    // 左子数组区间 [left, mid]
+    // 右子数组区间 [mid + 1, right]
     void merge(int[] nums, int left, int mid, int right)
     {
         // 初始化辅助数组
diff --git a/build/chapter_sorting/quick_sort.md b/build/chapter_sorting/quick_sort.md
index 7ef7cd9c1..1c4ab2a34 100755
--- a/build/chapter_sorting/quick_sort.md
+++ b/build/chapter_sorting/quick_sort.md
@@ -45,14 +45,14 @@ comments: true
 
 === "Java"
 
-    ``` java title="quick_sort.java"
+    ```java title="quick_sort.java"
     /* 元素交换 */
     void swap(int[] nums, int i, int j) {
         int tmp = nums[i];
         nums[i] = nums[j];
         nums[j] = tmp;
     }
-    
+
     /* 哨兵划分 */
     int partition(int[] nums, int left, int right) {
         // 以 nums[left] 作为基准数
@@ -468,7 +468,7 @@ comments: true
         else
             return right;
     }
-    
+
     /* 哨兵划分（三数取中值） */
     int partition(int[] nums, int left, int right) {
         // 选取三个候选元素的中位数
@@ -476,7 +476,16 @@ comments: true
         // 将中位数交换至数组最左端
         swap(nums, left, med);
         // 以 nums[left] 作为基准数
-        // 下同省略...
+        int i = left, j = right;
+        while (i < j) {
+            while (i < j && nums[j] >= nums[left])
+                j--;          // 从右向左找首个小于基准数的元素
+            while (i < j && nums[i] <= nums[left])
+                i++;          // 从左向右找首个大于基准数的元素
+            swap(nums, i, j); // 交换这两个元素
+        }
+        swap(nums, i, left);  // 将基准数交换至两子数组的分界线
+        return i;             // 返回基准数的索引
     }
     ```
 
diff --git a/build/chapter_stack_and_queue/deque.md b/build/chapter_stack_and_queue/deque.md
index 2ed4c866f..b49f3b20d 100644
--- a/build/chapter_stack_and_queue/deque.md
+++ b/build/chapter_stack_and_queue/deque.md
@@ -331,26 +331,26 @@ comments: true
             prev = next = null;
         }
     }
-    
+
     /* 基于双向链表实现的双向队列 */
     class LinkedListDeque {
-    private ListNode front, rear; // 头结点 front ，尾结点 rear
-    private int size = 0;         // 双向队列的长度
-    
+        private ListNode front, rear; // 头结点 front ，尾结点 rear
+        private int size = 0;         // 双向队列的长度
+
         public LinkedListDeque() {
             front = rear = null;
         }
-    
+
         /* 获取双向队列的长度 */
         public int size() {
             return size;
         }
-    
+
         /* 判断双向队列是否为空 */
         public boolean isEmpty() {
             return size() == 0;
         }
-    
+
         /* 入队操作 */
         private void push(int num, boolean isFront) {
             ListNode node = new ListNode(num);
@@ -372,17 +372,17 @@ comments: true
             }
             size++; // 更新队列长度
         }
-    
+
         /* 队首入队 */
         public void pushFirst(int num) {
             push(num, true);
         }
-    
+
         /* 队尾入队 */
         public void pushLast(int num) {
             push(num, false);
         }
-    
+
         /* 出队操作 */
         private Integer poll(boolean isFront) {
             // 若队列为空，直接返回 null
@@ -413,26 +413,41 @@ comments: true
             size--; // 更新队列长度
             return val;
         }
-    
+
         /* 队首出队 */
         public Integer pollFirst() {
             return poll(true);
         }
-    
+
         /* 队尾出队 */
         public Integer pollLast() {
             return poll(false);
         }
-    
+
         /* 访问队首元素 */
         public Integer peekFirst() {
             return isEmpty() ? null : front.val;
         }
-    
+
         /* 访问队尾元素 */
         public Integer peekLast() {
             return isEmpty() ? null : rear.val;
         }
+
+        /* 打印双向队列 */
+        public void print() {
+            if (isEmpty()) {
+                System.out.println("[ ]");
+                return;
+            }
+            List<String> list = new ArrayList<>();
+            ListNode head = front;
+            while (head != null) {
+                list.add(String.valueOf(head.val));
+                head = head.next;
+            }
+            System.out.println("[" + String.join(", ", list) + "]");
+        }
     }
     ```
 
diff --git a/build/chapter_stack_and_queue/queue.md b/build/chapter_stack_and_queue/queue.md
index 88de0a0bf..c3a58d284 100755
--- a/build/chapter_stack_and_queue/queue.md
+++ b/build/chapter_stack_and_queue/queue.md
@@ -288,19 +288,22 @@ comments: true
     class LinkedListQueue {
         private ListNode front, rear;  // 头结点 front ，尾结点 rear 
         private int queSize = 0;
-    
+
         public LinkedListQueue() {
             front = null;
             rear = null;
         }
+
         /* 获取队列的长度 */
         public int size() {
             return queSize;
         }
+
         /* 判断队列是否为空 */
         public boolean isEmpty() {
             return size() == 0;
         }
+
         /* 入队 */
         public void push(int num) {
             // 尾结点后添加 num
@@ -316,6 +319,7 @@ comments: true
             }
             queSize++;
         }
+
         /* 出队 */
         public int poll() {
             int num = peek();
@@ -324,12 +328,24 @@ comments: true
             queSize--;
             return num;
         }
+
         /* 访问队首元素 */
         public int peek() {
             if (size() == 0)
                 throw new EmptyStackException();
             return front.val;
         }
+
+        /* 将链表转化为 Array 并返回 */
+        public int[] toArray() {
+            ListNode node = front;
+            int[] res = new int[size()];
+            for (int i = 0; i < res.length; i++) {
+                res[i] = node.val;
+                node = node.next;
+            }
+            return res;
+        }
     }
     ```
 
@@ -815,6 +831,16 @@ comments: true
                 throw new EmptyStackException();
             return nums[front];
         }
+
+        /* 返回数组 */
+        public int[] toArray() {
+            // 仅转换有效长度范围内的列表元素
+            int[] res = new int[queSize];
+            for (int i = 0, j = front; i < queSize; i++, j++) {
+                res[i] = nums[j % capacity()];
+            }
+            return res;
+        }
     }
     ```
 
diff --git a/build/chapter_stack_and_queue/stack.md b/build/chapter_stack_and_queue/stack.md
index 3eda1a4df..894c03552 100755
--- a/build/chapter_stack_and_queue/stack.md
+++ b/build/chapter_stack_and_queue/stack.md
@@ -291,17 +291,21 @@ comments: true
     class LinkedListStack {
         private ListNode stackPeek;  // 将头结点作为栈顶
         private int stkSize = 0;   // 栈的长度
+        
         public LinkedListStack() {
             stackPeek = null;
         }
+
         /* 获取栈的长度 */
         public int size() {
             return stkSize;
         }
+
         /* 判断栈是否为空 */
         public boolean isEmpty() {
             return size() == 0;
         }
+
         /* 入栈 */
         public void push(int num) {
             ListNode node = new ListNode(num);
@@ -309,6 +313,7 @@ comments: true
             stackPeek = node;
             stkSize++;
         }
+
         /* 出栈 */
         public int pop() {
             int num = peek();
@@ -316,12 +321,24 @@ comments: true
             stkSize--;
             return num;
         }
+
         /* 访问栈顶元素 */
         public int peek() {
             if (size() == 0)
                 throw new EmptyStackException();
             return stackPeek.val;
         }
+
+        /* 将 List 转化为 Array 并返回 */
+        public int[] toArray() {
+            ListNode node = stackPeek;
+            int[] res = new int[size()];
+            for (int i = res.length - 1; i >= 0; i--) {
+                res[i] = node.val;
+                node = node.next;
+            }
+            return res;
+        }
     }
     ```
 
@@ -730,30 +747,40 @@ comments: true
             // 初始化列表（动态数组）
             stack = new ArrayList<>();
         }
+
         /* 获取栈的长度 */
         public int size() {
             return stack.size();
         }
+
         /* 判断栈是否为空 */
         public boolean isEmpty() {
             return size() == 0;
         }
+
         /* 入栈 */
         public void push(int num) {
             stack.add(num);
         }
+
         /* 出栈 */
         public int pop() {
             if (isEmpty())
                 throw new EmptyStackException();
             return stack.remove(size() - 1);
         }
+
         /* 访问栈顶元素 */
         public int peek() {
             if (isEmpty())
                 throw new EmptyStackException();
             return stack.get(size() - 1);
         }
+
+        /* 将 List 转化为 Array 并返回 */
+        public Object[] toArray() {
+            return stack.toArray();
+        }
     }
     ```
 
diff --git a/build/chapter_tree/avl_tree.md b/build/chapter_tree/avl_tree.md
index b1b2adb52..0d4a36fea 100755
--- a/build/chapter_tree/avl_tree.md
+++ b/build/chapter_tree/avl_tree.md
@@ -28,7 +28,7 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 
 === "Java"
 
-    ```java title="avl_tree.java"
+    ```java title=""
     /* AVL 树结点类 */
     class TreeNode {
         public int val; // 结点值
@@ -41,7 +41,7 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 
 === "C++"
 
-    ```cpp title="avl_tree.cpp"
+    ```cpp title=""
     /* AVL 树结点类 */
     struct TreeNode {
         int val{};              // 结点值
@@ -55,7 +55,7 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 
 === "Python"
 
-    ```python title="avl_tree.py"
+    ```python title=""
     """ AVL 树结点类 """
     class TreeNode:
         def __init__(self, val=None, left=None, right=None):
@@ -67,7 +67,7 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 
 === "Go"
 
-    ```go title="avl_tree.go"
+    ```go title=""
     /* AVL 树结点类 */
     type TreeNode struct {
         Val    int       // 结点值
@@ -79,36 +79,47 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 
 === "JavaScript"
 
-    ```js title="avl_tree.js"
+    ```js title=""
     class TreeNode {
         val; // 结点值
+        height; //结点高度
         left; // 左子结点指针
         right; // 右子结点指针
-        height; //结点高度
         constructor(val, left, right, height) {
             this.val = val === undefined ? 0 : val;
+            this.height = height === undefined ? 0 : height;
             this.left = left === undefined ? null : left;
             this.right = right === undefined ? null : right;
-            this.height = height === undefined ? 0 : height;
         }
     }
     ```
 
 === "TypeScript"
 
-    ```typescript title="avl_tree.ts"
-
+    ```typescript title=""
+    class TreeNode {
+        val: number;            // 结点值
+        height: number;         // 结点高度
+        left: TreeNode | null;  // 左子结点指针
+        right: TreeNode | null; // 右子结点指针
+        constructor(val?: number, height?: number, left?: TreeNode | null, right?: TreeNode | null) {
+            this.val = val === undefined ? 0 : val;
+            this.height = height === undefined ? 0 : height; 
+            this.left = left === undefined ? null : left; 
+            this.right = right === undefined ? null : right; 
+        }
+    }
     ```
 
 === "C"
 
-    ```c title="avl_tree.c"
+    ```c title=""
 
     ```
 
 === "C#"
 
-    ```csharp title="avl_tree.cs"
+    ```csharp title=""
     /* AVL 树结点类 */
     class TreeNode {
         public int val;          // 结点值
@@ -121,7 +132,7 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 
 === "Swift"
 
-    ```swift title="avl_tree.swift"
+    ```swift title=""
     /* AVL 树结点类 */
     class TreeNode {
         var val: Int // 结点值
@@ -138,7 +149,7 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 
 === "Zig"
 
-    ```zig title="avl_tree.zig"
+    ```zig title=""
 
     ```
 
@@ -236,7 +247,17 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 === "TypeScript"
 
     ```typescript title="avl_tree.ts"
+    /* 获取结点高度 */
+    height(node: TreeNode): number {
+        // 空结点高度为 -1 ，叶结点高度为 0
+        return node === null ? -1 : node.height;
+    }
 
+    /* 更新结点高度 */
+    updateHeight(node: TreeNode): void {
+        // 结点高度等于最高子树高度 + 1
+        node.height = Math.max(this.height(node.left), this.height(node.right)) + 1;
+    }
     ```
 
 === "C"
@@ -292,8 +313,8 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 === "Java"
 
     ```java title="avl_tree.java"
-    /* 获取结点平衡因子 */
-    public int balanceFactor(TreeNode node) {
+    /* 获取平衡因子 */
+    int balanceFactor(TreeNode node) {
         // 空结点平衡因子为 0
         if (node == null) return 0;
         // 结点平衡因子 = 左子树高度 - 右子树高度
@@ -354,7 +375,13 @@ G. M. Adelson-Velsky 和 E. M. Landis 在其 1962 年发表的论文 "An algorit
 === "TypeScript"
 
     ```typescript title="avl_tree.ts"
-
+    /* 获取平衡因子 */
+    balanceFactor(node: TreeNode): number {
+        // 空结点平衡因子为 0
+        if (node === null) return 0;
+        // 结点平衡因子 = 左子树高度 - 右子树高度
+        return this.height(node.left) - this.height(node.right);
+    }
     ```
 
 === "C"
@@ -408,7 +435,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 
 ### Case 1 - 右旋
 
-如下图所示（结点下方为「平衡因子」），从底至顶看，二叉树中首个失衡结点是 **结点 3**。我们聚焦在以该失衡结点为根结点的子树上，将该结点记为 `node` ，将其左子节点记为 `child` ，执行「右旋」操作。完成右旋后，该子树已经恢复平衡，并且仍然为二叉搜索树。
+如下图所示（结点下方为「平衡因子」），从底至顶看，二叉树中首个失衡结点是 **结点 3**。我们聚焦在以该失衡结点为根结点的子树上，将该结点记为 `node` ，将其左子结点记为 `child` ，执行「右旋」操作。完成右旋后，该子树已经恢复平衡，并且仍然为二叉搜索树。
 
 === "Step 1"
     ![right_rotate_step1](avl_tree.assets/right_rotate_step1.png)
@@ -441,7 +468,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         // 更新结点高度
         updateHeight(node);
         updateHeight(child);
-        // 返回旋转后子树的根节点
+        // 返回旋转后子树的根结点
         return child;
     }
     ```
@@ -459,7 +486,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         // 更新结点高度
         updateHeight(node);
         updateHeight(child);
-        // 返回旋转后子树的根节点
+        // 返回旋转后子树的根结点
         return child;
     }
     ```
@@ -477,7 +504,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         # 更新结点高度
         self.__update_height(node)
         self.__update_height(child)
-        # 返回旋转后子树的根节点
+        # 返回旋转后子树的根结点
         return child
     ```
 
@@ -494,7 +521,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         // 更新结点高度
         updateHeight(node)
         updateHeight(child)
-        // 返回旋转后子树的根节点
+        // 返回旋转后子树的根结点
         return child
     }
     ```
@@ -504,15 +531,15 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
     ```js title="avl_tree.js"
     /* 右旋操作 */
     rightRotate(node) {
-        let child = node.left;
-        let grandChild = child.right;
+        const child = node.left;
+        const grandChild = child.right;
         // 以 child 为原点，将 node 向右旋转
         child.right = node;
         node.left = grandChild;
         // 更新结点高度
         this.updateHeight(node);
         this.updateHeight(child);
-        // 返回旋转后子树的根节点
+        // 返回旋转后子树的根结点
         return child;
     }
     ```
@@ -520,7 +547,19 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "TypeScript"
 
     ```typescript title="avl_tree.ts"
-
+    /* 右旋操作 */
+    rightRotate(node: TreeNode): TreeNode {
+        const child = node.left;
+        const grandChild = child.right;
+        // 以 child 为原点，将 node 向右旋转
+        child.right = node;
+        node.left = grandChild;
+        // 更新结点高度
+        this.updateHeight(node);
+        this.updateHeight(child);
+        // 返回旋转后子树的根结点
+        return child;
+    }
     ```
 
 === "C"
@@ -543,7 +582,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         // 更新结点高度
         updateHeight(node);
         updateHeight(child);
-        // 返回旋转后子树的根节点
+        // 返回旋转后子树的根结点
         return child;
     }
     ```
@@ -561,7 +600,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         // 更新结点高度
         updateHeight(node: node)
         updateHeight(node: child)
-        // 返回旋转后子树的根节点
+        // 返回旋转后子树的根结点
         return child
     }
     ```
@@ -588,7 +627,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 
     ```java title="avl_tree.java"
     /* 左旋操作 */
-    private TreeNode leftRotate(TreeNode node) {
+    TreeNode leftRotate(TreeNode node) {
         TreeNode child = node.right;
         TreeNode grandChild = child.left;
         // 以 child 为原点，将 node 向左旋转
@@ -597,7 +636,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         // 更新结点高度
         updateHeight(node);
         updateHeight(child);
-        // 返回旋转后子树的根节点
+        // 返回旋转后子树的根结点
         return child;
     }
     ```
@@ -615,7 +654,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         // 更新结点高度
         updateHeight(node);
         updateHeight(child);
-        // 返回旋转后子树的根节点
+        // 返回旋转后子树的根结点
         return child;
     }
     ```
@@ -633,7 +672,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         # 更新结点高度
         self.__update_height(node)
         self.__update_height(child)
-        # 返回旋转后子树的根节点
+        # 返回旋转后子树的根结点
         return child
     ```
 
@@ -650,7 +689,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         // 更新结点高度
         updateHeight(node)
         updateHeight(child)
-        // 返回旋转后子树的根节点
+        // 返回旋转后子树的根结点
         return child
     }
     ```
@@ -660,15 +699,15 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
     ```js title="avl_tree.js"
     /* 左旋操作 */
     leftRotate(node) {
-        let child = node.right;
-        let grandChild = child.left;
+        const child = node.right;
+        const grandChild = child.left;
         // 以 child 为原点，将 node 向左旋转
         child.left = node;
         node.right = grandChild;
         // 更新结点高度
         this.updateHeight(node);
         this.updateHeight(child);
-        // 返回旋转后子树的根节点
+        // 返回旋转后子树的根结点
         return child;
     }
     ```
@@ -676,7 +715,19 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "TypeScript"
 
     ```typescript title="avl_tree.ts"
-
+    /* 左旋操作 */
+    leftRotate(node: TreeNode): TreeNode {
+        const child = node.right;
+        const grandChild = child.left;
+        // 以 child 为原点，将 node 向左旋转
+        child.left = node;
+        node.right = grandChild;
+        // 更新结点高度
+        this.updateHeight(node);
+        this.updateHeight(child);
+        // 返回旋转后子树的根结点
+        return child;
+    }
     ```
 
 === "C"
@@ -701,7 +752,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         // 更新结点高度
         updateHeight(node);
         updateHeight(child);
-        // 返回旋转后子树的根节点
+        // 返回旋转后子树的根结点
         return child;
     }
     ```
@@ -719,7 +770,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         // 更新结点高度
         updateHeight(node: node)
         updateHeight(node: child)
-        // 返回旋转后子树的根节点
+        // 返回旋转后子树的根结点
         return child
     }
 
@@ -902,7 +953,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
     /* 执行旋转操作，使该子树重新恢复平衡 */
     rotate(node) {
         // 获取结点 node 的平衡因子
-        let balanceFactor = this.balanceFactor(node);
+        const balanceFactor = this.balanceFactor(node);
         // 左偏树
         if (balanceFactor > 1) {
             if (this.balanceFactor(node.left) >= 0) {
@@ -933,7 +984,35 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "TypeScript"
 
     ```typescript title="avl_tree.ts"
-
+    /* 执行旋转操作，使该子树重新恢复平衡 */
+    rotate(node: TreeNode): TreeNode {
+        // 获取结点 node 的平衡因子
+        const balanceFactor = this.balanceFactor(node);
+        // 左偏树
+        if (balanceFactor > 1) {
+            if (this.balanceFactor(node.left) >= 0) {
+                // 右旋
+                return this.rightRotate(node);
+            } else {
+                // 先左旋后右旋
+                node.left = this.leftRotate(node.left);
+                return this.rightRotate(node);
+            }
+        }
+        // 右偏树
+        if (balanceFactor < -1) {
+            if (this.balanceFactor(node.right) <= 0) {
+                // 左旋
+                return this.leftRotate(node);
+            } else {
+                // 先右旋后左旋
+                node.right = this.rightRotate(node.right);
+                return this.leftRotate(node);
+            }
+        }
+        // 平衡树，无需旋转，直接返回
+        return node;
+    }
     ```
 
 === "C"
@@ -1049,11 +1128,11 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         else if (val > node.val)
             node.right = insertHelper(node.right, val);
         else
-            return node; // 重复结点不插入，直接返回
-        updateHeight(node); // 更新结点高度
+            return node;     // 重复结点不插入，直接返回
+        updateHeight(node);  // 更新结点高度
         /* 2. 执行旋转操作，使该子树重新恢复平衡 */
         node = rotate(node);
-        // 返回子树的根节点
+        // 返回子树的根结点
         return node;
     }
     ```
@@ -1080,7 +1159,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         updateHeight(node);  // 更新结点高度
         /* 2. 执行旋转操作，使该子树重新恢复平衡 */
         node = rotate(node);
-        // 返回子树的根节点
+        // 返回子树的根结点
         return node;
     }
     ```
@@ -1137,7 +1216,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         updateHeight(node)
         /* 2. 执行旋转操作，使该子树重新恢复平衡 */
         node = rotate(node)
-        // 返回子树的根节点
+        // 返回子树的根结点
         return node
     }
     ```
@@ -1161,7 +1240,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         this.updateHeight(node); // 更新结点高度
         /* 2. 执行旋转操作，使该子树重新恢复平衡 */
         node = this.rotate(node);
-        // 返回子树的根节点
+        // 返回子树的根结点
         return node;
     }
     ```
@@ -1169,7 +1248,29 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "TypeScript"
 
     ```typescript title="avl_tree.ts"
+    /* 插入结点 */
+    insert(val: number): TreeNode {
+        this.root = this.insertHelper(this.root, val);
+        return this.root;
+    }
 
+    /* 递归插入结点（辅助函数） */
+    insertHelper(node: TreeNode, val: number): TreeNode {
+        if (node === null) return new TreeNode(val);
+        /* 1. 查找插入位置，并插入结点 */
+        if (val < node.val) {
+            node.left = this.insertHelper(node.left, val);
+        } else if (val > node.val) {
+            node.right = this.insertHelper(node.right, val);
+        } else {
+            return node; // 重复结点不插入，直接返回
+        }
+        this.updateHeight(node); // 更新结点高度
+        /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+        node = this.rotate(node);
+        // 返回子树的根结点
+        return node;
+    }
     ```
 
 === "C"
@@ -1204,7 +1305,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         updateHeight(node);  // 更新结点高度
         /* 2. 执行旋转操作，使该子树重新恢复平衡 */
         node = rotate(node);
-        // 返回子树的根节点
+        // 返回子树的根结点
         return node;
     }
     ```
@@ -1236,7 +1337,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         updateHeight(node: node) // 更新结点高度
         /* 2. 执行旋转操作，使该子树重新恢复平衡 */
         node = rotate(node: node)
-        // 返回子树的根节点
+        // 返回子树的根结点
         return node
     }
     ```
@@ -1284,10 +1385,20 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
                 node.val = temp.val;
             }
         }
-        updateHeight(node); // 更新结点高度
+        updateHeight(node);  // 更新结点高度
         /* 2. 执行旋转操作，使该子树重新恢复平衡 */
         node = rotate(node);
-        // 返回子树的根节点
+        // 返回子树的根结点
+        return node;
+    }
+
+    /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+    TreeNode getInOrderNext(TreeNode node) {
+        if (node == null) return node;
+        // 循环访问左子结点，直到叶结点时为最小结点，跳出
+        while (node.left != null) {
+            node = node.left;
+        }
         return node;
     }
     ```
@@ -1332,7 +1443,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         updateHeight(node);  // 更新结点高度
         /* 2. 执行旋转操作，使该子树重新恢复平衡 */
         node = rotate(node);
-        // 返回子树的根节点
+        // 返回子树的根结点
         return node;
     }
     ```
@@ -1416,7 +1527,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         updateHeight(node)
         /* 2. 执行旋转操作，使该子树重新恢复平衡 */
         node = rotate(node)
-        // 返回子树的根节点
+        // 返回子树的根结点
         return node
     }
     ```
@@ -1438,14 +1549,14 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         else if (val > node.val) node.right = this.removeHelper(node.right, val);
         else {
             if (node.left === null || node.right === null) {
-                let child = node.left !== null ? node.left : node.right;
+                const child = node.left !== null ? node.left : node.right;
                 // 子结点数量 = 0 ，直接删除 node 并返回
                 if (child === null) return null;
                 // 子结点数量 = 1 ，直接删除 node
                 else node = child;
             } else {
                 // 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
-                let temp = this.getInOrderNext(node.right);
+                const temp = this.getInOrderNext(node.right);
                 node.right = this.removeHelper(node.right, temp.val);
                 node.val = temp.val;
             }
@@ -1453,7 +1564,27 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         this.updateHeight(node); // 更新结点高度
         /* 2. 执行旋转操作，使该子树重新恢复平衡 */
         node = this.rotate(node);
-        // 返回子树的根节点
+        // 返回子树的根结点
+        return node;
+    }
+
+    /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+    getInOrderNext(node) {
+        if (node === null) return node;
+        // 循环访问左子结点，直到叶结点时为最小结点，跳出
+        while (node.left !== null) {
+            node = node.left;
+        }
+        return node;
+    }
+
+    /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+    getInOrderNext(node) {
+        if (node === null) return node;
+        // 循环访问左子结点，直到叶结点时为最小结点，跳出
+        while (node.left !== null) {
+            node = node.left;
+        }
         return node;
     }
     ```
@@ -1461,7 +1592,53 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
 === "TypeScript"
 
     ```typescript title="avl_tree.ts"
+    /* 删除结点 */
+    remove(val: number): TreeNode {
+        this.root = this.removeHelper(this.root, val);
+        return this.root;
+    }
 
+    /* 递归删除结点（辅助函数） */
+    removeHelper(node: TreeNode, val: number): TreeNode {
+        if (node === null) return null;
+        /* 1. 查找结点，并删除之 */
+        if (val < node.val) {
+            node.left = this.removeHelper(node.left, val);
+        } else if (val > node.val) {
+            node.right = this.removeHelper(node.right, val);
+        } else {
+            if (node.left === null || node.right === null) {
+                const child = node.left !== null ? node.left : node.right;
+                // 子结点数量 = 0 ，直接删除 node 并返回
+                if (child === null) {
+                    return null;
+                } else {
+                    // 子结点数量 = 1 ，直接删除 node
+                     node = child;
+                }
+            } else {
+                // 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+                const temp = this.getInOrderNext(node.right);
+                node.right = this.removeHelper(node.right, temp.val);
+                node.val = temp.val;
+            }
+        }
+        this.updateHeight(node); // 更新结点高度
+        /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+        node = this.rotate(node);
+        // 返回子树的根结点
+        return node;
+    }
+
+    /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
+    getInOrderNext(node: TreeNode): TreeNode {
+        if (node === null) return node;
+        // 循环访问左子结点，直到叶结点时为最小结点，跳出
+        while (node.left !== null) {
+            node = node.left;
+        }
+        return node;
+    }
     ```
 
 === "C"
@@ -1512,7 +1689,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         updateHeight(node);  // 更新结点高度
         /* 2. 执行旋转操作，使该子树重新恢复平衡 */
         node = rotate(node);
-        // 返回子树的根节点
+        // 返回子树的根结点
         return node;
     }
     ```
@@ -1559,7 +1736,7 @@ AVL 树的独特之处在于「旋转 Rotation」的操作，其可 **在不影
         updateHeight(node: node) // 更新结点高度
         /* 2. 执行旋转操作，使该子树重新恢复平衡 */
         node = rotate(node: node)
-        // 返回子树的根节点
+        // 返回子树的根结点
         return node
     }
     ```
diff --git a/build/chapter_tree/binary_search_tree.md b/build/chapter_tree/binary_search_tree.md
index df69cecc2..11d70a0d2 100755
--- a/build/chapter_tree/binary_search_tree.md
+++ b/build/chapter_tree/binary_search_tree.md
@@ -556,8 +556,6 @@ comments: true
             // 删除结点 cur
             if (pre.left == cur) pre.left = child;
             else pre.right = child;
-            // 释放内存
-            delete cur;
         }
         // 子结点数量 = 2
         else {
@@ -573,7 +571,7 @@ comments: true
     }
 
     /* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
-    public TreeNode getInOrderNext(TreeNode root) {
+    TreeNode getInOrderNext(TreeNode root) {
         if (root == null) return root;
         // 循环访问左子结点，直到叶结点时为最小结点，跳出
         while (root.left != null) {
diff --git a/build/chapter_tree/binary_tree.md b/build/chapter_tree/binary_tree.md
index 2e876d539..c82750b45 100644
--- a/build/chapter_tree/binary_tree.md
+++ b/build/chapter_tree/binary_tree.md
@@ -197,7 +197,7 @@ comments: true
 
     ```python title="binary_tree.py"
     """ 初始化二叉树 """
-    # 初始化节点
+    # 初始化结点
     n1 = TreeNode(val=1)
     n2 = TreeNode(val=2)
     n3 = TreeNode(val=3)
@@ -343,7 +343,7 @@ comments: true
     # 在 n1 -> n2 中间插入结点 P
     n1.left = p
     p.left = n2
-    # 删除节点 P
+    # 删除结点 P
     n1.left = n2
     ```
 
diff --git a/build/chapter_tree/binary_tree_traversal.md b/build/chapter_tree/binary_tree_traversal.md
index 197cb0bb5..eb19b9451 100755
--- a/build/chapter_tree/binary_tree_traversal.md
+++ b/build/chapter_tree/binary_tree_traversal.md
@@ -52,7 +52,7 @@ comments: true
         while (!queue.empty()) {
             TreeNode* node = queue.front();
             queue.pop();                 // 队列出队
-            vec.push_back(node->val);    // 保存结点
+            vec.push_back(node->val);    // 保存结点值
             if (node->left != nullptr)
                 queue.push(node->left);  // 左子结点入队
             if (node->right != nullptr)
@@ -74,7 +74,7 @@ comments: true
         res = []
         while queue:
             node = queue.popleft()       # 队列出队
-            res.append(node.val)         # 保存节点值
+            res.append(node.val)         # 保存结点值
             if node.left is not None:
                 queue.append(node.left)  # 左子结点入队
             if node.right is not None:
@@ -95,7 +95,7 @@ comments: true
         for queue.Len() > 0 {
             // poll
             node := queue.Remove(queue.Front()).(*TreeNode)
-            // 保存结点
+            // 保存结点值
             nums = append(nums, node.Val)
             if node.Left != nil {
                 // 左子结点入队
@@ -120,12 +120,12 @@ comments: true
         // 初始化一个列表，用于保存遍历序列
         let list = [];
         while (queue.length) {
-            let node = queue.shift();  // 队列出队
-            list.push(node.val);          // 保存结点
+            let node = queue.shift();   // 队列出队
+            list.push(node.val);        // 保存结点值
             if (node.left)
-                queue.push(node.left);    // 左子结点入队
+                queue.push(node.left);  // 左子结点入队
             if (node.right)
-                queue.push(node.right);   // 右子结点入队
+                queue.push(node.right); // 右子结点入队
         }
         return list;
     }
@@ -142,7 +142,7 @@ comments: true
         const list: number[] = [];
         while (queue.length) {
             let node = queue.shift() as TreeNode; // 队列出队
-            list.push(node.val); // 保存结点
+            list.push(node.val); // 保存结点值
             if (node.left) {
                 queue.push(node.left); // 左子结点入队
             }
@@ -196,7 +196,7 @@ comments: true
         var list: [Int] = []
         while !queue.isEmpty {
             let node = queue.removeFirst() // 队列出队
-            list.append(node.val) // 保存结点
+            list.append(node.val) // 保存结点值
             if let left = node.left {
                 queue.append(left) // 左子结点入队
             }
@@ -245,7 +245,7 @@ comments: true
         preOrder(root.left);
         preOrder(root.right);
     }
-    
+
     /* 中序遍历 */
     void inOrder(TreeNode root) {
         if (root == null) return;
@@ -254,7 +254,7 @@ comments: true
         list.add(root.val);
         inOrder(root.right);
     }
-    
+
     /* 后序遍历 */
     void postOrder(TreeNode root) {
         if (root == null) return;
diff --git a/build/stylesheets/extra.css b/build/stylesheets/extra.css
index 4f153c794..7171f2ed1 100644
--- a/build/stylesheets/extra.css
+++ b/build/stylesheets/extra.css
@@ -67,4 +67,10 @@
 body {
   --md-text-font-family: -apple-system,BlinkMacSystemFont,var(--md-text-font,_),Helvetica,Arial,sans-serif;
   --md-code-font-family: var(--md-code-font,_),SFMono-Regular,Consolas,Menlo,-apple-system,BlinkMacSystemFont,var(--md-text-font,_),monospace;
-}
\ No newline at end of file
+}
+
+/* max height of code block */
+/* https://github.com/squidfunk/mkdocs-material/issues/3444 */
+.md-typeset pre > code {
+  max-height: 30rem;
+}