github/hello-algo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix code naming style.

Browse Source
This commit is contained in:
krahets 2023-10-15 21:18:09 +08:00
parent ada37fd1f8
commit 346c8451de
23 changed files with 51 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
codes/c/chapter_array_and_linkedlist/linked_list.c
View File

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

2
codes/c/chapter_graph/graph_adjacency_list.c
View File

@ -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 *temp = l->head->next;
Node *front = l->head; Node *front = l->head;
while (temp != 0) { while (temp != 0) {

2
codes/c/chapter_stack_and_queue/linkedlist_deque.c
View File

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

4
codes/c/chapter_tree/avl_tree.c
View File

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

10
codes/c/chapter_tree/binary_search_tree.c
View File

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

8
codes/csharp/chapter_divide_and_conquer/binary_search_recur.cs
View File

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

8
codes/csharp/chapter_divide_and_conquer/build_tree.cs
View File

@ -8,7 +8,7 @@ namespace hello_algo.chapter_divide_and_conquer;
public class build_tree { 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) if (r - l < 0)
return null; return null;
@ -17,9 +17,9 @@ public class build_tree {
// 查询 m ，从而划分左右子树 // 查询 m ，从而划分左右子树
int m = inorderMap[preorder[i]]; 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; return root;
} }
@ -31,7 +31,7 @@ public class build_tree {
for (int i = 0; i < inorder.Length; i++) { for (int i = 0; i < inorder.Length; i++) {
inorderMap.TryAdd(inorder[i], 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; return root;
} }

8
codes/csharp/chapter_divide_and_conquer/hanota.cs
View File

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

6
codes/csharp/chapter_dynamic_programming/climbing_stairs_dfs.cs
View File

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

6
codes/csharp/chapter_dynamic_programming/climbing_stairs_dfs_mem.cs
View File

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

6
codes/csharp/chapter_graph/graph_dfs.cs
View File

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

12
codes/csharp/chapter_tree/array_binary_tree.cs
View File

@ -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) if (!Val(i).HasValue)
return; return;
// 前序遍历 // 前序遍历
if (order == "pre") if (order == "pre")
res.Add(Val(i).Value); res.Add(Val(i).Value);
Dfs(Left(i), order, res); DFS(Left(i), order, res);
// 中序遍历 // 中序遍历
if (order == "in") if (order == "in")
res.Add(Val(i).Value); res.Add(Val(i).Value);
Dfs(Right(i), order, res); DFS(Right(i), order, res);
// 后序遍历 // 后序遍历
if (order == "post") if (order == "post")
res.Add(Val(i).Value); res.Add(Val(i).Value);
@ -75,21 +75,21 @@ public class ArrayBinaryTree {
/* 前序遍历 */ /* 前序遍历 */
public List<int> PreOrder() { public List<int> PreOrder() {
List<int> res = new(); List<int> res = new();
Dfs(0, "pre", res); DFS(0, "pre", res);
return res; return res;
} }
/* 中序遍历 */ /* 中序遍历 */
public List<int> InOrder() { public List<int> InOrder() {
List<int> res = new(); List<int> res = new();
Dfs(0, "in", res); DFS(0, "in", res);
return res; return res;
} }
/* 后序遍历 */ /* 后序遍历 */
public List<int> PostOrder() { public List<int> PostOrder() {
List<int> res = new(); List<int> res = new();
Dfs(0, "post", res); DFS(0, "post", res);
return res; return res;
} }
} }

2
codes/go/chapter_array_and_linkedlist/linked_list.go
View File

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

2
codes/go/chapter_array_and_linkedlist/linked_list_test.go
View File

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

2
codes/python/chapter_tree/avl_tree.py
View File

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

4
docs/chapter_array_and_linkedlist/linked_list.md
View File

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

2
docs/chapter_divide_and_conquer/binary_search_recur.md
View File

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

2
docs/chapter_divide_and_conquer/build_binary_tree_problem.md
View File

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

2
docs/chapter_divide_and_conquer/hanota_problem.md
View File

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

4
docs/chapter_dynamic_programming/intro_to_dynamic_programming.md
View File

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

2
docs/chapter_graph/graph_traversal.md
View File

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

2
docs/chapter_tree/avl_tree.md
View File

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

2
docs/chapter_tree/binary_search_tree.md
View File

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