CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-04-13 18:00:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix(csharp): Modify method name to PascalCase, simplify new expression (#840)

Browse Source 
* Modify method name to PascalCase(array and linked list)

* Modify method name to PascalCase(backtracking)

* Modify method name to PascalCase(computational complexity)

* Modify method name to PascalCase(divide and conquer)

* Modify method name to PascalCase(dynamic programming)

* Modify method name to PascalCase(graph)

* Modify method name to PascalCase(greedy)

* Modify method name to PascalCase(hashing)

* Modify method name to PascalCase(heap)

* Modify method name to PascalCase(searching)

* Modify method name to PascalCase(sorting)

* Modify method name to PascalCase(stack and queue)

* Modify method name to PascalCase(tree)

* local check
This commit is contained in:
hpstory
2023-10-08 01:33:46 +08:00
committed by GitHub
parent 6f7e768cb7
commit f62256bee1
129 changed files with 1186 additions and 1192 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -8,7 +8,7 @@ namespace hello_algo.chapter_tree;
/* 数组表示下的二叉树类 */
public class ArrayBinaryTree {
private List<int?> tree;
private readonly List<int?> tree;
/* 构造方法 */
public ArrayBinaryTree(List<int?> arr) {
@@ -16,80 +16,80 @@ public class ArrayBinaryTree {
}
/* 节点数量 */
public int size() {
public int Size() {
return tree.Count;
}
/* 获取索引为 i 节点的值 */
public int? val(int i) {
public int? Val(int i) {
// 若索引越界，则返回 null ，代表空位
if (i < 0 || i >= size())
if (i < 0 || i >= Size())
return null;
return tree[i];
}
/* 获取索引为 i 节点的左子节点的索引 */
public int left(int i) {
public int Left(int i) {
return 2 * i + 1;
}
/* 获取索引为 i 节点的右子节点的索引 */
public int right(int i) {
public int Right(int i) {
return 2 * i + 2;
}
/* 获取索引为 i 节点的父节点的索引 */
public int parent(int i) {
public int Parent(int i) {
return (i - 1) / 2;
}
/* 层序遍历 */
public List<int> levelOrder() {
List<int> res = new List<int>();
public List<int> LevelOrder() {
List<int> res = new();
// 直接遍历数组
for (int i = 0; i < size(); i++) {
if (val(i).HasValue)
res.Add(val(i).Value);
for (int i = 0; i < Size(); i++) {
if (Val(i).HasValue)
res.Add(Val(i).Value);
}
return res;
}
/* 深度优先遍历 */
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;
// 前序遍历
if (order == "pre")
res.Add(val(i).Value);
dfs(left(i), order, res);
res.Add(Val(i).Value);
Dfs(Left(i), order, res);
// 中序遍历
if (order == "in")
res.Add(val(i).Value);
dfs(right(i), order, res);
res.Add(Val(i).Value);
Dfs(Right(i), order, res);
// 后序遍历
if (order == "post")
res.Add(val(i).Value);
res.Add(Val(i).Value);
}
/* 前序遍历 */
public List<int> preOrder() {
List<int> res = new List<int>();
dfs(0, "pre", res);
public List<int> PreOrder() {
List<int> res = new();
Dfs(0, "pre", res);
return res;
}
/* 中序遍历 */
public List<int> inOrder() {
List<int> res = new List<int>();
dfs(0, "in", res);
public List<int> InOrder() {
List<int> res = new();
Dfs(0, "in", res);
return res;
}
/* 后序遍历 */
public List<int> postOrder() {
List<int> res = new List<int>();
dfs(0, "post", res);
public List<int> PostOrder() {
List<int> res = new();
Dfs(0, "post", res);
return res;
}
}
@@ -99,7 +99,7 @@ public class array_binary_tree {
public void Test() {
// 初始化二叉树
// 这里借助了一个从数组直接生成二叉树的函数
List<int?> arr = new List<int?> { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };
List<int?> arr = new() { 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 };
TreeNode root = TreeNode.ListToTree(arr);
Console.WriteLine("\n初始化二叉树\n");
@@ -109,26 +109,26 @@ public class array_binary_tree {
PrintUtil.PrintTree(root);
// 数组表示下的二叉树类
ArrayBinaryTree abt = new ArrayBinaryTree(arr);
ArrayBinaryTree abt = new(arr);
// 访问节点
int i = 1;
int l = abt.left(i);
int r = abt.right(i);
int p = abt.parent(i);
Console.WriteLine("\n当前节点的索引为 " + i + " ，值为 " + abt.val(i));
Console.WriteLine("其左子节点的索引为 " + l + " ，值为 " + (abt.val(l).HasValue ? abt.val(l) : "null"));
Console.WriteLine("其右子节点的索引为 " + r + " ，值为 " + (abt.val(r).HasValue ? abt.val(r) : "null"));
Console.WriteLine("其父节点的索引为 " + p + " ，值为 " + (abt.val(p).HasValue ? abt.val(p) : "null"));
int l = abt.Left(i);
int r = abt.Right(i);
int p = abt.Parent(i);
Console.WriteLine("\n当前节点的索引为 " + i + " ，值为 " + abt.Val(i));
Console.WriteLine("其左子节点的索引为 " + l + " ，值为 " + (abt.Val(l).HasValue ? abt.Val(l) : "null"));
Console.WriteLine("其右子节点的索引为 " + r + " ，值为 " + (abt.Val(r).HasValue ? abt.Val(r) : "null"));
Console.WriteLine("其父节点的索引为 " + p + " ，值为 " + (abt.Val(p).HasValue ? abt.Val(p) : "null"));
// 遍历树
List<int> res = abt.levelOrder();
List<int> res = abt.LevelOrder();
Console.WriteLine("\n层序遍历为：" + res.PrintList());
res = abt.preOrder();
res = abt.PreOrder();
Console.WriteLine("前序遍历为：" + res.PrintList());
res = abt.inOrder();
res = abt.InOrder();
Console.WriteLine("中序遍历为：" + res.PrintList());
res = abt.postOrder();
res = abt.PostOrder();
Console.WriteLine("后序遍历为：" + res.PrintList());
}
}

116
codes/csharp/chapter_tree/avl_tree.cs
View File

@@ -11,77 +11,77 @@ class AVLTree {
public TreeNode? root; // 根节点
/* 获取节点高度 */
public int height(TreeNode? node) {
public int Height(TreeNode? node) {
// 空节点高度为 -1 ，叶节点高度为 0
return node == null ? -1 : node.height;
}
/* 更新节点高度 */
private void updateHeight(TreeNode node) {
private void UpdateHeight(TreeNode node) {
// 节点高度等于最高子树高度 + 1
node.height = Math.Max(height(node.left), height(node.right)) + 1;
node.height = Math.Max(Height(node.left), Height(node.right)) + 1;
}
/* 获取平衡因子 */
public int balanceFactor(TreeNode? node) {
public int BalanceFactor(TreeNode? node) {
// 空节点平衡因子为 0
if (node == null) return 0;
// 节点平衡因子 = 左子树高度 - 右子树高度
return height(node.left) - height(node.right);
return Height(node.left) - Height(node.right);
}
/* 右旋操作 */
TreeNode? rightRotate(TreeNode? node) {
TreeNode? RightRotate(TreeNode? node) {
TreeNode? child = node.left;
TreeNode? grandChild = child?.right;
// 以 child 为原点，将 node 向右旋转
child.right = node;
node.left = grandChild;
// 更新节点高度
updateHeight(node);
updateHeight(child);
UpdateHeight(node);
UpdateHeight(child);
// 返回旋转后子树的根节点
return child;
}
/* 左旋操作 */
TreeNode? leftRotate(TreeNode? node) {
TreeNode? LeftRotate(TreeNode? node) {
TreeNode? child = node.right;
TreeNode? grandChild = child?.left;
// 以 child 为原点，将 node 向左旋转
child.left = node;
node.right = grandChild;
// 更新节点高度
updateHeight(node);
updateHeight(child);
UpdateHeight(node);
UpdateHeight(child);
// 返回旋转后子树的根节点
return child;
}
/* 执行旋转操作，使该子树重新恢复平衡 */
TreeNode? rotate(TreeNode? node) {
TreeNode? Rotate(TreeNode? node) {
// 获取节点 node 的平衡因子
int balanceFactorInt = balanceFactor(node);
int balanceFactorInt = BalanceFactor(node);
// 左偏树
if (balanceFactorInt > 1) {
if (balanceFactor(node.left) >= 0) {
if (BalanceFactor(node.left) >= 0) {
// 右旋
return rightRotate(node);
return RightRotate(node);
} else {
// 先左旋后右旋
node.left = leftRotate(node?.left);
return rightRotate(node);
node.left = LeftRotate(node?.left);
return RightRotate(node);
}
}
// 右偏树
if (balanceFactorInt < -1) {
if (balanceFactor(node.right) <= 0) {
if (BalanceFactor(node.right) <= 0) {
// 左旋
return leftRotate(node);
return LeftRotate(node);
} else {
// 先右旋后左旋
node.right = rightRotate(node?.right);
return leftRotate(node);
node.right = RightRotate(node?.right);
return LeftRotate(node);
}
}
// 平衡树，无须旋转，直接返回
@@ -89,43 +89,43 @@ class AVLTree {
}
/* 插入节点 */
public void insert(int val) {
root = insertHelper(root, val);
public void Insert(int val) {
root = InsertHelper(root, val);
}
/* 递归插入节点（辅助方法） */
private TreeNode? insertHelper(TreeNode? node, int val) {
private TreeNode? InsertHelper(TreeNode? node, int val) {
if (node == null) return new TreeNode(val);
/* 1. 查找插入位置，并插入节点 */
if (val < node.val)
node.left = insertHelper(node.left, val);
node.left = InsertHelper(node.left, val);
else if (val > node.val)
node.right = insertHelper(node.right, val);
node.right = InsertHelper(node.right, val);
else
return node; // 重复节点不插入，直接返回
updateHeight(node); // 更新节点高度
UpdateHeight(node); // 更新节点高度
/* 2. 执行旋转操作，使该子树重新恢复平衡 */
node = rotate(node);
node = Rotate(node);
// 返回子树的根节点
return node;
}
/* 删除节点 */
public void remove(int val) {
root = removeHelper(root, val);
public void Remove(int val) {
root = RemoveHelper(root, val);
}
/* 递归删除节点（辅助方法） */
private TreeNode? removeHelper(TreeNode? node, int val) {
private TreeNode? RemoveHelper(TreeNode? node, int val) {
if (node == null) return null;
/* 1. 查找节点，并删除之 */
if (val < node.val)
node.left = removeHelper(node.left, val);
node.left = RemoveHelper(node.left, val);
else if (val > node.val)
node.right = removeHelper(node.right, val);
node.right = RemoveHelper(node.right, val);
else {
if (node.left == null || node.right == null) {
TreeNode? child = node.left != null ? node.left : node.right;
TreeNode? child = node.left ?? node.right;
// 子节点数量 = 0 ，直接删除 node 并返回
if (child == null)
return null;
@@ -138,19 +138,19 @@ class AVLTree {
while (temp.left != null) {
temp = temp.left;
}
node.right = removeHelper(node.right, temp.val);
node.right = RemoveHelper(node.right, temp.val);
node.val = temp.val;
}
}
updateHeight(node); // 更新节点高度
UpdateHeight(node); // 更新节点高度
/* 2. 执行旋转操作，使该子树重新恢复平衡 */
node = rotate(node);
node = Rotate(node);
// 返回子树的根节点
return node;
}
/* 查找节点 */
public TreeNode? search(int val) {
public TreeNode? Search(int val) {
TreeNode? cur = root;
// 循环查找，越过叶节点后跳出
while (cur != null) {
@@ -170,14 +170,14 @@ class AVLTree {
}
public class avl_tree {
static void testInsert(AVLTree tree, int val) {
tree.insert(val);
static void TestInsert(AVLTree tree, int val) {
tree.Insert(val);
Console.WriteLine("\n插入节点 " + val + " 后，AVL 树为");
PrintUtil.PrintTree(tree.root);
}
static void testRemove(AVLTree tree, int val) {
tree.remove(val);
static void TestRemove(AVLTree tree, int val) {
tree.Remove(val);
Console.WriteLine("\n删除节点 " + val + " 后，AVL 树为");
PrintUtil.PrintTree(tree.root);
}
@@ -185,32 +185,32 @@ public class avl_tree {
[Test]
public void Test() {
/* 初始化空 AVL 树 */
AVLTree avlTree = new AVLTree();
AVLTree avlTree = new();
/* 插入节点 */
// 请关注插入节点后，AVL 树是如何保持平衡的
testInsert(avlTree, 1);
testInsert(avlTree, 2);
testInsert(avlTree, 3);
testInsert(avlTree, 4);
testInsert(avlTree, 5);
testInsert(avlTree, 8);
testInsert(avlTree, 7);
testInsert(avlTree, 9);
testInsert(avlTree, 10);
testInsert(avlTree, 6);
TestInsert(avlTree, 1);
TestInsert(avlTree, 2);
TestInsert(avlTree, 3);
TestInsert(avlTree, 4);
TestInsert(avlTree, 5);
TestInsert(avlTree, 8);
TestInsert(avlTree, 7);
TestInsert(avlTree, 9);
TestInsert(avlTree, 10);
TestInsert(avlTree, 6);
/* 插入重复节点 */
testInsert(avlTree, 7);
TestInsert(avlTree, 7);
/* 删除节点 */
// 请关注删除节点后，AVL 树是如何保持平衡的
testRemove(avlTree, 8); // 删除度为 0 的节点
testRemove(avlTree, 5); // 删除度为 1 的节点
testRemove(avlTree, 4); // 删除度为 2 的节点
TestRemove(avlTree, 8); // 删除度为 0 的节点
TestRemove(avlTree, 5); // 删除度为 1 的节点
TestRemove(avlTree, 4); // 删除度为 2 的节点
/* 查询节点 */
TreeNode? node = avlTree.search(7);
TreeNode? node = avlTree.Search(7);
Console.WriteLine("\n查找到的节点对象为 " + node + "，节点值 = " + node?.val);
}
}

38
codes/csharp/chapter_tree/binary_search_tree.cs
View File

@@ -15,12 +15,12 @@ class BinarySearchTree {
}
/* 获取二叉树根节点 */
public TreeNode? getRoot() {
public TreeNode? GetRoot() {
return root;
}
/* 查找节点 */
public TreeNode? search(int num) {
public TreeNode? Search(int num) {
TreeNode? cur = root;
// 循环查找，越过叶节点后跳出
while (cur != null) {
@@ -39,7 +39,7 @@ class BinarySearchTree {
}
/* 插入节点 */
public void insert(int num) {
public void Insert(int num) {
// 若树为空，则初始化根节点
if (root == null) {
root = new TreeNode(num);
@@ -61,7 +61,7 @@ class BinarySearchTree {
}
// 插入节点
TreeNode node = new TreeNode(num);
TreeNode node = new(num);
if (pre != null) {
if (pre.val < num)
pre.right = node;
@@ -72,7 +72,7 @@ class BinarySearchTree {
/* 删除节点 */
public void remove(int num) {
public void Remove(int num) {
// 若树为空，直接提前返回
if (root == null)
return;
@@ -96,7 +96,7 @@ class BinarySearchTree {
// 子节点数量 = 0 or 1
if (cur.left == null || cur.right == null) {
// 当子节点数量 = 0 / 1 时， child = null / 该子节点
TreeNode? child = cur.left != null ? cur.left : cur.right;
TreeNode? child = cur.left ?? cur.right;
// 删除节点 cur
if (cur != root) {
if (pre.left == cur)
@@ -116,7 +116,7 @@ class BinarySearchTree {
tmp = tmp.left;
}
// 递归删除节点 tmp
remove(tmp.val);
Remove(tmp.val);
// 用 tmp 覆盖 cur
cur.val = tmp.val;
}
@@ -127,34 +127,34 @@ public class binary_search_tree {
[Test]
public void Test() {
/* 初始化二叉搜索树 */
BinarySearchTree bst = new BinarySearchTree();
BinarySearchTree bst = new();
// 请注意，不同的插入顺序会生成不同的二叉树，该序列可以生成一个完美二叉树
int[] nums = { 8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15 };
foreach (int num in nums) {
bst.insert(num);
bst.Insert(num);
}
Console.WriteLine("\n初始化的二叉树为\n");
PrintUtil.PrintTree(bst.getRoot());
PrintUtil.PrintTree(bst.GetRoot());
/* 查找节点 */
TreeNode? node = bst.search(7);
TreeNode? node = bst.Search(7);
Console.WriteLine("\n查找到的节点对象为 " + node + "，节点值 = " + node.val);
/* 插入节点 */
bst.insert(16);
bst.Insert(16);
Console.WriteLine("\n插入节点 16 后，二叉树为\n");
PrintUtil.PrintTree(bst.getRoot());
PrintUtil.PrintTree(bst.GetRoot());
/* 删除节点 */
bst.remove(1);
bst.Remove(1);
Console.WriteLine("\n删除节点 1 后，二叉树为\n");
PrintUtil.PrintTree(bst.getRoot());
bst.remove(2);
PrintUtil.PrintTree(bst.GetRoot());
bst.Remove(2);
Console.WriteLine("\n删除节点 2 后，二叉树为\n");
PrintUtil.PrintTree(bst.getRoot());
bst.remove(4);
PrintUtil.PrintTree(bst.GetRoot());
bst.Remove(4);
Console.WriteLine("\n删除节点 4 后，二叉树为\n");
PrintUtil.PrintTree(bst.getRoot());
PrintUtil.PrintTree(bst.GetRoot());
}
}

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

@@ -11,11 +11,11 @@ public class binary_tree {
public void Test() {
/* 初始化二叉树 */
// 初始化节点
TreeNode n1 = new TreeNode(1);
TreeNode n2 = new TreeNode(2);
TreeNode n3 = new TreeNode(3);
TreeNode n4 = new TreeNode(4);
TreeNode n5 = new TreeNode(5);
TreeNode n1 = new(1);
TreeNode n2 = new(2);
TreeNode n3 = new(3);
TreeNode n4 = new(4);
TreeNode n5 = new(5);
// 构建引用指向（即指针）
n1.left = n2;
n1.right = n3;
@@ -25,7 +25,7 @@ public class binary_tree {
PrintUtil.PrintTree(n1);
/* 插入与删除节点 */
TreeNode P = new TreeNode(0);
TreeNode P = new(0);
// 在 n1 -> n2 中间插入节点 P
n1.left = P;
P.left = n2;

4
codes/csharp/chapter_tree/binary_tree_bfs.cs
View File

@@ -9,7 +9,7 @@ namespace hello_algo.chapter_tree;
public class binary_tree_bfs {
/* 层序遍历 */
public List<int> levelOrder(TreeNode root) {
public List<int> LevelOrder(TreeNode root) {
// 初始化队列，加入根节点
Queue<TreeNode> queue = new();
queue.Enqueue(root);
@@ -34,7 +34,7 @@ public class binary_tree_bfs {
Console.WriteLine("\n初始化二叉树\n");
PrintUtil.PrintTree(root);
List<int> list = levelOrder(root);
List<int> list = LevelOrder(root);
Console.WriteLine("\n层序遍历的节点打印序列 = " + string.Join(",", list));
}
}

26
codes/csharp/chapter_tree/binary_tree_dfs.cs
View File

@@ -7,32 +7,32 @@
namespace hello_algo.chapter_tree;
public class binary_tree_dfs {
List<int> list = new();
readonly List<int> list = new();
/* 前序遍历 */
void preOrder(TreeNode? root) {
void PreOrder(TreeNode? root) {
if (root == null) return;
// 访问优先级：根节点 -> 左子树 -> 右子树
list.Add(root.val);
preOrder(root.left);
preOrder(root.right);
PreOrder(root.left);
PreOrder(root.right);
}
/* 中序遍历 */
void inOrder(TreeNode? root) {
void InOrder(TreeNode? root) {
if (root == null) return;
// 访问优先级：左子树 -> 根节点 -> 右子树
inOrder(root.left);
InOrder(root.left);
list.Add(root.val);
inOrder(root.right);
InOrder(root.right);
}
/* 后序遍历 */
void postOrder(TreeNode? root) {
void PostOrder(TreeNode? root) {
if (root == null) return;
// 访问优先级：左子树 -> 右子树 -> 根节点
postOrder(root.left);
postOrder(root.right);
PostOrder(root.left);
PostOrder(root.right);
list.Add(root.val);
}
@@ -45,15 +45,15 @@ public class binary_tree_dfs {
PrintUtil.PrintTree(root);
list.Clear();
preOrder(root);
PreOrder(root);
Console.WriteLine("\n前序遍历的节点打印序列 = " + string.Join(",", list));
list.Clear();
inOrder(root);
InOrder(root);
Console.WriteLine("\n中序遍历的节点打印序列 = " + string.Join(",", list));
list.Clear();
postOrder(root);
PostOrder(root);
Console.WriteLine("\n后序遍历的节点打印序列 = " + string.Join(",", list));
}
}