Fix code naming style.

codes/c/chapter_array_and_linkedlist/linked_list.c

@@ -15,7 +15,7 @@ void insert(ListNode *n0, ListNode *P) {
 
 /* 删除链表的节点 n0 之后的首个节点 */
 // 注意：stdio.h 占用了 remove 关键词
-void removeNode(ListNode *n0) {
+void removeItem(ListNode *n0) {
     if (!n0->next)
         return;
     // n0 -> P -> n1
@@ -70,7 +70,7 @@ int main() {
     printLinkedList(n0);
 
     /* 删除节点 */
-    removeNode(n0);
+    removeItem(n0);
     printf("删除节点后的链表为\r\n");
     printLinkedList(n0);
 

codes/c/chapter_graph/graph_adjacency_list.c

@@ -104,7 +104,7 @@ void removeLink(linkList *l, Vertex *val) {
 }
 
 /* 根据顶点地址删除顶点 */
-void removeNode(linkList *l, Vertex *val) {
+void removeItem(linkList *l, Vertex *val) {
     Node *temp = l->head->next;
     Node *front = l->head;
     while (temp != 0) {

codes/c/chapter_stack_and_queue/linkedlist_deque.c

@@ -82,7 +82,7 @@ void push(linkedListDeque *deque, int num, bool isFront) {
         node->next = deque->front;
         deque->front = node; // 更新头节点
     }
-    // 对尾入队操作
+    // 队尾入队操作
     else {
         // 将 node 添加至链表尾部
         deque->rear->next = node;

codes/c/chapter_tree/avl_tree.c

@@ -183,7 +183,7 @@ TreeNode *removeHelper(TreeNode *node, int val) {
 
 /* 删除节点 */
 // 由于引入了 stdio.h ，此处无法使用 remove 关键词
-void removeNode(aVLTree *tree, int val) {
+void removeItem(aVLTree *tree, int val) {
     TreeNode *root = removeHelper(tree->root, val);
 }
 
@@ -214,7 +214,7 @@ void testInsert(aVLTree *tree, int val) {
 }
 
 void testRemove(aVLTree *tree, int val) {
-    removeNode(tree, val);
+    removeItem(tree, val);
     printf("\n删除节点 %d 后，AVL 树为 \n", val);
     printTree(tree->root);
 }

codes/c/chapter_tree/binary_search_tree.c

@@ -102,7 +102,7 @@ void insert(binarySearchTree *bst, int num) {
 
 /* 删除节点 */
 // 由于引入了 stdio.h ，此处无法使用 remove 关键词
-void removeNode(binarySearchTree *bst, int num) {
+void removeItem(binarySearchTree *bst, int num) {
     // 若树为空，直接提前返回
     if (bst->root == NULL)
         return;
@@ -144,7 +144,7 @@ void removeNode(binarySearchTree *bst, int num) {
         }
         int tmpVal = tmp->val;
         // 递归删除节点 tmp
-        removeNode(bst, tmp->val);
+        removeItem(bst, tmp->val);
         // 用 tmp 覆盖 cur
         cur->val = tmpVal;
     }
@@ -168,13 +168,13 @@ int main() {
     printTree(getRoot(bst));
 
     /* 删除节点 */
-    removeNode(bst, 1);
+    removeItem(bst, 1);
     printf("删除节点 1 后，二叉树为\n");
     printTree(getRoot(bst));
-    removeNode(bst, 2);
+    removeItem(bst, 2);
     printf("删除节点 2 后，二叉树为\n");
     printTree(getRoot(bst));
-    removeNode(bst, 4);
+    removeItem(bst, 4);
     printf("删除节点 4 后，二叉树为\n");
     printTree(getRoot(bst));
 

codes/csharp/chapter_divide_and_conquer/binary_search_recur.cs

@@ -8,7 +8,7 @@ namespace hello_algo.chapter_divide_and_conquer;
 
 public class binary_search_recur {
     /* 二分查找：问题 f(i, j) */
-    public int Dfs(int[] nums, int target, int i, int j) {
+    public int DFS(int[] nums, int target, int i, int j) {
         // 若区间为空，代表无目标元素，则返回 -1
         if (i > j) {
             return -1;
@@ -17,10 +17,10 @@ public class binary_search_recur {
         int m = (i + j) / 2;
         if (nums[m] < target) {
             // 递归子问题 f(m+1, j)
-            return Dfs(nums, target, m + 1, j);
+            return DFS(nums, target, m + 1, j);
         } else if (nums[m] > target) {
             // 递归子问题 f(i, m-1)
-            return Dfs(nums, target, i, m - 1);
+            return DFS(nums, target, i, m - 1);
         } else {
             // 找到目标元素，返回其索引
             return m;
@@ -31,7 +31,7 @@ public class binary_search_recur {
     public int BinarySearch(int[] nums, int target) {
         int n = nums.Length;
         // 求解问题 f(0, n-1)
-        return Dfs(nums, target, 0, n - 1);
+        return DFS(nums, target, 0, n - 1);
     }
 
     [Test]

codes/csharp/chapter_divide_and_conquer/build_tree.cs

@@ -8,7 +8,7 @@ namespace hello_algo.chapter_divide_and_conquer;
 
 public class build_tree {
     /* 构建二叉树：分治 */
-    public TreeNode Dfs(int[] preorder, Dictionary<int, int> inorderMap, int i, int l, int r) {
+    public TreeNode DFS(int[] preorder, Dictionary<int, int> inorderMap, int i, int l, int r) {
         // 子树区间为空时终止
         if (r - l < 0)
             return null;
@@ -17,9 +17,9 @@ public class build_tree {
         // 查询 m ，从而划分左右子树
         int m = inorderMap[preorder[i]];
         // 子问题：构建左子树
-        root.left = Dfs(preorder, inorderMap, i + 1, l, m - 1);
+        root.left = DFS(preorder, inorderMap, i + 1, l, m - 1);
         // 子问题：构建右子树
-        root.right = Dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
+        root.right = DFS(preorder, inorderMap, i + 1 + m - l, m + 1, r);
         // 返回根节点
         return root;
     }
@@ -31,7 +31,7 @@ public class build_tree {
         for (int i = 0; i < inorder.Length; i++) {
             inorderMap.TryAdd(inorder[i], i);
         }
-        TreeNode root = Dfs(preorder, inorderMap, 0, 0, inorder.Length - 1);
+        TreeNode root = DFS(preorder, inorderMap, 0, 0, inorder.Length - 1);
         return root;
     }
 

codes/csharp/chapter_divide_and_conquer/hanota.cs

@@ -17,25 +17,25 @@ public class hanota {
     }
 
     /* 求解汉诺塔：问题 f(i) */
-    public void Dfs(int i, List<int> src, List<int> buf, List<int> tar) {
+    public void DFS(int i, List<int> src, List<int> buf, List<int> tar) {
         // 若 src 只剩下一个圆盘，则直接将其移到 tar
         if (i == 1) {
             Move(src, tar);
             return;
         }
         // 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
-        Dfs(i - 1, src, tar, buf);
+        DFS(i - 1, src, tar, buf);
         // 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
         Move(src, tar);
         // 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
-        Dfs(i - 1, buf, src, tar);
+        DFS(i - 1, buf, src, tar);
     }
 
     /* 求解汉诺塔 */
     public void SolveHanota(List<int> A, List<int> B, List<int> C) {
         int n = A.Count;
         // 将 A 顶部 n 个圆盘借助 B 移到 C
-        Dfs(n, A, B, C);
+        DFS(n, A, B, C);
     }
 
     [Test]

codes/csharp/chapter_dynamic_programming/climbing_stairs_dfs.cs

@@ -8,18 +8,18 @@ namespace hello_algo.chapter_dynamic_programming;
 
 public class climbing_stairs_dfs {
     /* 搜索 */
-    public int Dfs(int i) {
+    public int DFS(int i) {
         // 已知 dp[1] 和 dp[2] ，返回之
         if (i == 1 || i == 2)
             return i;
         // dp[i] = dp[i-1] + dp[i-2]
-        int count = Dfs(i - 1) + Dfs(i - 2);
+        int count = DFS(i - 1) + DFS(i - 2);
         return count;
     }
 
     /* 爬楼梯：搜索 */
     public int ClimbingStairsDFS(int n) {
-        return Dfs(n);
+        return DFS(n);
     }
 
     [Test]

codes/csharp/chapter_dynamic_programming/climbing_stairs_dfs_mem.cs

@@ -8,7 +8,7 @@ namespace hello_algo.chapter_dynamic_programming;
 
 public class climbing_stairs_dfs_mem {
     /* 记忆化搜索 */
-    public int Dfs(int i, int[] mem) {
+    public int DFS(int i, int[] mem) {
         // 已知 dp[1] 和 dp[2] ，返回之
         if (i == 1 || i == 2)
             return i;
@@ -16,7 +16,7 @@ public class climbing_stairs_dfs_mem {
         if (mem[i] != -1)
             return mem[i];
         // dp[i] = dp[i-1] + dp[i-2]
-        int count = Dfs(i - 1, mem) + Dfs(i - 2, mem);
+        int count = DFS(i - 1, mem) + DFS(i - 2, mem);
         // 记录 dp[i]
         mem[i] = count;
         return count;
@@ -27,7 +27,7 @@ public class climbing_stairs_dfs_mem {
         // mem[i] 记录爬到第 i 阶的方案总数，-1 代表无记录
         int[] mem = new int[n + 1];
         Array.Fill(mem, -1);
-        return Dfs(n, mem);
+        return DFS(n, mem);
     }
 
     [Test]

codes/csharp/chapter_graph/graph_dfs.cs

@@ -8,7 +8,7 @@ namespace hello_algo.chapter_graph;
 
 public class graph_dfs {
     /* 深度优先遍历 DFS 辅助函数 */
-    public void Dfs(GraphAdjList graph, HashSet<Vertex> visited, List<Vertex> res, Vertex vet) {
+    public void DFS(GraphAdjList graph, HashSet<Vertex> visited, List<Vertex> res, Vertex vet) {
         res.Add(vet);     // 记录访问顶点
         visited.Add(vet); // 标记该顶点已被访问
         // 遍历该顶点的所有邻接顶点
@@ -17,7 +17,7 @@ public class graph_dfs {
                 continue; // 跳过已被访问过的顶点                             
             }
             // 递归访问邻接顶点
-            Dfs(graph, visited, res, adjVet);
+            DFS(graph, visited, res, adjVet);
         }
     }
 
@@ -28,7 +28,7 @@ public class graph_dfs {
         List<Vertex> res = new();
         // 哈希表，用于记录已被访问过的顶点
         HashSet<Vertex> visited = new();
-        Dfs(graph, visited, res, startVet);
+        DFS(graph, visited, res, startVet);
         return res;
     }
 

codes/csharp/chapter_tree/array_binary_tree.cs

@@ -55,18 +55,18 @@ public class ArrayBinaryTree {
     }
 
     /* 深度优先遍历 */
-    private void Dfs(int i, string order, List<int> res) {
+    private void DFS(int i, string order, List<int> res) {
         // 若为空位，则返回
         if (!Val(i).HasValue)
             return;
         // 前序遍历
         if (order == "pre")
             res.Add(Val(i).Value);
-        Dfs(Left(i), order, res);
+        DFS(Left(i), order, res);
         // 中序遍历
         if (order == "in")
             res.Add(Val(i).Value);
-        Dfs(Right(i), order, res);
+        DFS(Right(i), order, res);
         // 后序遍历
         if (order == "post")
             res.Add(Val(i).Value);
@@ -75,21 +75,21 @@ public class ArrayBinaryTree {
     /* 前序遍历 */
     public List<int> PreOrder() {
         List<int> res = new();
-        Dfs(0, "pre", res);
+        DFS(0, "pre", res);
         return res;
     }
 
     /* 中序遍历 */
     public List<int> InOrder() {
         List<int> res = new();
-        Dfs(0, "in", res);
+        DFS(0, "in", res);
         return res;
     }
 
     /* 后序遍历 */
     public List<int> PostOrder() {
         List<int> res = new();
-        Dfs(0, "post", res);
+        DFS(0, "post", res);
         return res;
     }
 }

codes/go/chapter_array_and_linkedlist/linked_list.go

@@ -16,7 +16,7 @@ func insertNode(n0 *ListNode, P *ListNode) {
 }
 
 /* 删除链表的节点 n0 之后的首个节点 */
-func removeNode(n0 *ListNode) {
+func removeItem(n0 *ListNode) {
 	if n0.Next == nil {
 		return
 	}

codes/go/chapter_array_and_linkedlist/linked_list_test.go

@@ -34,7 +34,7 @@ func TestLinkedList(t *testing.T) {
 	PrintLinkedList(n0)
 
 	/* 删除节点 */
-	removeNode(n0)
+	removeItem(n0)
 	fmt.Println("删除节点后的链表为")
 	PrintLinkedList(n0)
 

codes/python/chapter_tree/avl_tree.py

@@ -13,7 +13,7 @@ from modules import *
 class AVLTree:
     """AVL 树"""
 
-    def __init__(self, root: TreeNode | None = None):
+    def __init__(self):
         """构造方法"""
         self._root = None
 

docs/chapter_array_and_linkedlist/linked_list.md

@@ -512,7 +512,7 @@
 === "Go"
 
     ```go title="linked_list.go"
-    [class]{}-[func]{removeNode}
+    [class]{}-[func]{removeItem}
     ```
 
 === "Swift"
@@ -548,7 +548,7 @@
 === "C"
 
     ```c title="linked_list.c"
-    [class]{}-[func]{removeNode}
+    [class]{}-[func]{removeItem}
     ```
 
 === "Zig"

docs/chapter_divide_and_conquer/binary_search_recur.md

@@ -67,7 +67,7 @@
 === "C#"
 
     ```csharp title="binary_search_recur.cs"
-    [class]{binary_search_recur}-[func]{Dfs}
+    [class]{binary_search_recur}-[func]{DFS}
 
     [class]{binary_search_recur}-[func]{BinarySearch}
     ```

docs/chapter_divide_and_conquer/build_binary_tree_problem.md

@@ -84,7 +84,7 @@
 === "C#"
 
     ```csharp title="build_tree.cs"
-    [class]{build_tree}-[func]{Dfs}
+    [class]{build_tree}-[func]{DFS}
 
     [class]{build_tree}-[func]{BuildTree}
     ```

docs/chapter_divide_and_conquer/hanota_problem.md

@@ -117,7 +117,7 @@
     ```csharp title="hanota.cs"
     [class]{hanota}-[func]{Move}
 
-    [class]{hanota}-[func]{Dfs}
+    [class]{hanota}-[func]{DFS}
 
     [class]{hanota}-[func]{SolveHanota}
     ```

docs/chapter_dynamic_programming/intro_to_dynamic_programming.md

@@ -163,7 +163,7 @@ $$
 === "C#"
 
     ```csharp title="climbing_stairs_dfs.cs"
-    [class]{climbing_stairs_dfs}-[func]{Dfs}
+    [class]{climbing_stairs_dfs}-[func]{DFS}
 
     [class]{climbing_stairs_dfs}-[func]{ClimbingStairsDFS}
     ```
@@ -274,7 +274,7 @@ $$
 === "C#"
 
     ```csharp title="climbing_stairs_dfs_mem.cs"
-    [class]{climbing_stairs_dfs_mem}-[func]{Dfs}
+    [class]{climbing_stairs_dfs_mem}-[func]{DFS}
 
     [class]{climbing_stairs_dfs_mem}-[func]{ClimbingStairsDFSMem}
     ```

docs/chapter_graph/graph_traversal.md

@@ -174,7 +174,7 @@ BFS 通常借助队列来实现。队列具有“先入先出”的性质，这
 === "C#"
 
     ```csharp title="graph_dfs.cs"
-    [class]{graph_dfs}-[func]{Dfs}
+    [class]{graph_dfs}-[func]{DFS}
 
     [class]{graph_dfs}-[func]{GraphDFS}
     ```

docs/chapter_tree/avl_tree.md

@@ -863,7 +863,7 @@ AVL 树的节点插入操作与二叉搜索树在主体上类似。唯一的区
 === "C"
 
     ```c title="avl_tree.c"
-    [class]{aVLTree}-[func]{removeNode}
+    [class]{aVLTree}-[func]{removeItem}
 
     [class]{}-[func]{removeHelper}
     ```

docs/chapter_tree/binary_search_tree.md

@@ -293,7 +293,7 @@
 === "C"
 
     ```c title="binary_search_tree.c"
-    [class]{binarySearchTree}-[func]{removeNode}
+    [class]{binarySearchTree}-[func]{removeItem}
     ```
 
 === "Zig"