xinyin025/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-07-09 22:16:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fine tune

Browse Source
This commit is contained in:
Yudong Jin
2022-12-24 16:15:41 +08:00
parent 3339a648d0
commit b1645c7d7e
24 changed files with 235 additions and 233 deletions
Download Patch File Download Diff File Expand all files Collapse all files
codes/csharp/chapter_tree/avl_tree.cs
+5 -5
View File
@@ -148,7 +148,7 @@ namespace hello_algo.chapter_tree
}
/* 递归删除结点（辅助函数） */
private TreeNode? removeHelper(TreeNode? node, int? val)
private TreeNode? removeHelper(TreeNode? node, int val)
{
if (node == null) return null;
/* 1. 查找结点，并删除之 */
@@ -172,8 +172,8 @@ namespace hello_algo.chapter_tree
{
// 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
TreeNode? temp = minNode(node.right);
node.right = removeHelper(node.right, temp?.val);
node.val = temp?.val;
node.right = removeHelper(node.right, temp.val);
node.val = temp.val;
}
}
updateHeight(node); // 更新结点高度
@@ -223,14 +223,14 @@ namespace hello_algo.chapter_tree
{
tree.insert(val);
Console.WriteLine("\n插入结点 " + val + " 后，AVL 树为");
PrintUtil.printTree(tree.root);
PrintUtil.PrintTree(tree.root);
}
static void testRemove(AVLTree tree, int val)
{
tree.remove(val);
Console.WriteLine("\n删除结点 " + val + " 后，AVL 树为");
PrintUtil.printTree(tree.root);
PrintUtil.PrintTree(tree.root);
}
[Test]
codes/csharp/chapter_tree/binary_search_tree.cs
+53 -48
View File
@@ -9,16 +9,38 @@ using NUnit.Framework;
namespace hello_algo.chapter_tree
{
internal class binary_search_tree
class BinarySearchTree
{
TreeNode? root;
public BinarySearchTree(int[] nums) {
Array.Sort(nums); // 排序数组
root = buildTree(nums, 0, nums.Length - 1); // 构建二叉搜索树
}
/* 获取二叉树根结点 */
public TreeNode? getRoot() {
return root;
}
/* 构建二叉搜索树 */
public TreeNode? buildTree(int[] nums, int i, int j) {
if (i > j) return null;
// 将数组中间结点作为根结点
int mid = (i + j) / 2;
TreeNode root = new TreeNode(nums[mid]);
// 递归建立左子树和右子树
root.left = buildTree(nums, i, mid - 1);
root.right = buildTree(nums, mid + 1, j);
return root;
}
/// <summary>
/// 查找结点
/// </summary>
/// <param name="num"></param>
/// <returns></returns>
TreeNode? search(int num)
public TreeNode? search(int num)
{
TreeNode? cur = root;
// 循环查找，越过叶结点后跳出
@@ -36,7 +58,7 @@ namespace hello_algo.chapter_tree
}
/* 插入结点 */
TreeNode? insert(int num)
public TreeNode? insert(int num)
{
// 若树为空，直接提前返回
if (root == null) return null;
@@ -65,7 +87,7 @@ namespace hello_algo.chapter_tree
/* 删除结点 */
TreeNode? remove(int? num)
public TreeNode? remove(int num)
{
// 若树为空，直接提前返回
if (root == null) return null;
@@ -106,7 +128,7 @@ namespace hello_algo.chapter_tree
TreeNode? nex = min(cur.right);
if (nex != null)
{
int? tmp = nex.val;
int tmp = nex.val;
// 递归删除结点 nex
remove(nex.val);
// 将 nex 的值复制给 cur
@@ -117,7 +139,7 @@ namespace hello_algo.chapter_tree
}
/* 获取最小结点 */
TreeNode? min(TreeNode? root)
private TreeNode? min(TreeNode? root)
{
if (root == null) return root;
// 循环访问左子结点，直到叶结点时为最小结点，跳出
@@ -127,55 +149,38 @@ namespace hello_algo.chapter_tree
}
return root;
}
}
public class binary_search_tree
{
[Test]
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 n6 = new TreeNode(6);
TreeNode n7 = new TreeNode(7);
TreeNode n8 = new TreeNode(8);
TreeNode n9 = new TreeNode(9);
TreeNode n10 = new TreeNode(10);
TreeNode n11 = new TreeNode(11);
TreeNode n12 = new TreeNode(12);
TreeNode n13 = new TreeNode(13);
TreeNode n14 = new TreeNode(14);
TreeNode n15 = new TreeNode(15);
root = n8;
root.left = n4;
root.right = n12;
n4.left = n2;
n4.right = n6;
n12.left = n10;
n12.right = n14;
n2.left = n1;
n2.right = n3;
n6.left = n5;
n6.right = n7;
n10.left = n9;
n10.right = n11;
n14.left = n13;
n14.right = n15;
/* 初始化二叉搜索树 */
int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
BinarySearchTree bst = new BinarySearchTree(nums);
Console.WriteLine("\n初始化的二叉树为\n");
PrintUtil.PrintTree(bst.getRoot());
var cur = search(7);
Console.WriteLine("查找结点 结果 = " + cur?.val);
/* 查找结点 */
TreeNode? node = bst.search(5);
Console.WriteLine("\n查找到的结点对象为 " + node + "，结点值 = " + node.val);
var node = insert(16);
Console.WriteLine("插入结点 结果 = " + node?.val);
node = remove(1);
Console.WriteLine("删除结点 结果 = " + node?.val);
node = remove(2);
Console.WriteLine("删除结点 结果 = " + node?.val);
node = remove(4);
Console.WriteLine("删除结点 结果 = " + node?.val);
/* 插入结点 */
node = bst.insert(16);
Console.WriteLine("\n插入结点 16 后，二叉树为\n");
PrintUtil.PrintTree(bst.getRoot());
/* 删除结点 */
bst.remove(1);
Console.WriteLine("\n删除结点 1 后，二叉树为\n");
PrintUtil.PrintTree(bst.getRoot());
bst.remove(2);
Console.WriteLine("\n删除结点 2 后，二叉树为\n");
PrintUtil.PrintTree(bst.getRoot());
bst.remove(4);
Console.WriteLine("\n删除结点 4 后，二叉树为\n");
PrintUtil.PrintTree(bst.getRoot());
}
}
}
codes/csharp/chapter_tree/binary_tree.cs
+3 -3
View File
@@ -28,7 +28,7 @@ namespace hello_algo.chapter_tree
n2.left = n4;
n2.right = n5;
Console.WriteLine("\n初始化二叉树\n");
PrintUtil.printTree(n1);
PrintUtil.PrintTree(n1);
/* 插入与删除结点 */
TreeNode P = new TreeNode(0);
@@ -36,11 +36,11 @@ namespace hello_algo.chapter_tree
n1.left = P;
P.left = n2;
Console.WriteLine("\n插入结点 P 后\n");
PrintUtil.printTree(n1);
PrintUtil.PrintTree(n1);
// 删除结点 P
n1.left = n2;
Console.WriteLine("\n删除结点 P 后\n");
PrintUtil.printTree(n1);
PrintUtil.PrintTree(n1);
}
}
}
codes/csharp/chapter_tree/binary_tree_bfs.cs
+12 -82
View File
@@ -17,17 +17,17 @@ namespace hello_algo.chapter_tree
/// </summary>
/// <param name="root"></param>
/// <returns></returns>
public List<int?> hierOrder(TreeNode root)
public List<int> hierOrder(TreeNode root)
{
// 初始化队列，加入根结点
Queue<TreeNode> queue = new();
queue.Enqueue(root);
// 初始化一个列表，用于保存遍历序列
List<int?> list = new();
List<int> list = new();
while (queue.Count != 0)
{
TreeNode node = queue.Dequeue(); // 队列出队
list.Add(node.val); // 保存结点值
TreeNode node = queue.Dequeue(); // 队列出队
list.Add(node.val); // 保存结点值
if (node.left != null)
queue.Enqueue(node.left); // 左子结点入队
if (node.right != null)
@@ -36,88 +36,18 @@ namespace hello_algo.chapter_tree
return list;
}
List<int?> list = new();
/// <summary>
/// 前序遍历
/// </summary>
/// <param name="root"></param>
void preOrder(TreeNode? root)
{
if (root == null) return;
// 访问优先级：根结点 -> 左子树 -> 右子树
list.Add(root.val);
preOrder(root.left);
preOrder(root.right);
}
/// <summary>
/// 中序遍历
/// </summary>
/// <param name="root"></param>
void inOrder(TreeNode? root)
{
if (root == null) return;
// 访问优先级：左子树 -> 根结点 -> 右子树
inOrder(root.left);
list.Add(root.val);
inOrder(root.right);
}
/// <summary>
/// 后序遍历
/// </summary>
/// <param name="root"></param>
void postOrder(TreeNode? root)
{
if (root == null) return;
// 访问优先级：左子树 -> 右子树 -> 根结点
postOrder(root.left);
postOrder(root.right);
list.Add(root.val);
}
/// <summary>
/// 辅助函数,数组转字符串
/// </summary>
public static string ToString(int?[] nums)
{
return string.Join(",", nums);
}
[Test]
public void Test()
{
// 初始化结点
TreeNode root = new TreeNode(1);
TreeNode n2 = new TreeNode(2);
TreeNode n3 = new TreeNode(3);
TreeNode n4 = new TreeNode(4);
TreeNode n5 = new TreeNode(5);
TreeNode n6 = new TreeNode(6);
TreeNode n7 = new TreeNode(7);
// 构建引用指向（即指针）
root.left = n2;
root.right = n3;
n2.left = n4;
n2.right = n5;
n3.left = n6;
n3.right = n7;
/* 初始化二叉树 */
// 这里借助了一个从数组直接生成二叉树的函数
TreeNode? root = TreeNode.ArrToTree(new int?[] {
1, 2, 3, 4, 5, 6, 7, null, null, null, null, null, null, null, null});
Console.WriteLine("\n初始化二叉树\n");
PrintUtil.PrintTree(root);
list = hierOrder(root);
Console.WriteLine("层序遍历 结果 = " + ToString(list.ToArray()));
list = new List<int?>();
preOrder(root);
Console.WriteLine("前序遍历 结果 = " + ToString(list.ToArray()));
list = new List<int?>();
inOrder(root);
Console.WriteLine("中序遍历 结果 = " + ToString(list.ToArray()));
list = new List<int?>();
postOrder(root);
Console.WriteLine("后序遍历 结果 = " + ToString(list.ToArray()));
List<int> list = hierOrder(root);
Console.WriteLine("\n层序遍历的结点打印序列 = " + string.Join(",", list.ToArray()));
}
}
}
codes/csharp/chapter_tree/binary_tree_dfs.cs
+78
View File
@@ -0,0 +1,78 @@
/**
* File: binary_tree_bfs.cs
* Created Time: 2022-12-23
* Author: haptear (haptear@hotmail.com)
*/
using hello_algo.include;
using NUnit.Framework;
namespace hello_algo.chapter_tree
{
public class binary_tree_dfs
{
List<int> list = new();
/// <summary>
/// 前序遍历
/// </summary>
/// <param name="root"></param>
void preOrder(TreeNode? root)
{
if (root == null) return;
// 访问优先级：根结点 -> 左子树 -> 右子树
list.Add(root.val);
preOrder(root.left);
preOrder(root.right);
}
/// <summary>
/// 中序遍历
/// </summary>
/// <param name="root"></param>
void inOrder(TreeNode? root)
{
if (root == null) return;
// 访问优先级：左子树 -> 根结点 -> 右子树
inOrder(root.left);
list.Add(root.val);
inOrder(root.right);
}
/// <summary>
/// 后序遍历
/// </summary>
/// <param name="root"></param>
void postOrder(TreeNode? root)
{
if (root == null) return;
// 访问优先级：左子树 -> 右子树 -> 根结点
postOrder(root.left);
postOrder(root.right);
list.Add(root.val);
}
[Test]
public void Test()
{
/* 初始化二叉树 */
// 这里借助了一个从数组直接生成二叉树的函数
TreeNode? root = TreeNode.ArrToTree(new int?[] {
1, 2, 3, 4, 5, 6, 7, null, null, null, null, null, null, null, null});
Console.WriteLine("\n初始化二叉树\n");
PrintUtil.PrintTree(root);
list.Clear();
preOrder(root);
Console.WriteLine("\n前序遍历的结点打印序列 = " + string.Join(",", list.ToArray()));
list.Clear();
inOrder(root);
Console.WriteLine("\n中序遍历的结点打印序列 = " + string.Join(",", list.ToArray()));
list.Clear();
postOrder(root);
Console.WriteLine("\n后序遍历的结点打印序列 = " + string.Join(",", list.ToArray()));
}
}
}