C# 实现二叉排序树

最新推荐文章于 2022-06-29 09:42:24 发布
最新推荐文章于 2022-06-29 09:42:24 发布
阅读量558 收藏 2
点赞数
分类专栏： 数据结构学习笔记 文章标签： 二叉树 数据结构 算法 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FHelloWorld/article/details/109540910
版权

目录

二叉排序树

介绍

BST(Binary Sort Tree)，对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大
[注] 如果有相同的值，可以将该节点放在左子节点或右子节点(根据创建算法不同自行决定)

创建思路

class Node
{
	void Add(待添加节点 node)
	{
		如果node为空，直接返回
		
		if(node的Value 小于当前节点的Value)
		{
			如果当前节点的Left为空，则将当前节点的Left指向node
			
			否则就向左递归 this.Left.Add(node);	
		}
	}
}

删除节点思路

情况一：删除的节点是叶子节点

  1. 先找到待删除的节点 targetNode
  2. 找到targetNode的父亲节点 parent
  3. 确定targetNode是parent的左子节点还是右子节点
  4. 根据 3 中的情况进行删除
    左： parent.Left = null
    右： parent.Right = null

情况二：删除的节点有一个子节点

  1. 找到targetNode及parent
  2. 确定targetNode的子节点是左子节点还是右子节点
    左：Y = Left
    右：Y = Right
  3. 确定targetNode是parent的左子节点还是右子节点
    左：X = Left
    右：Y = Right
  4. parent.X = targetNode.Y;
    即用targetNode的子节点替换targetNode
    [注] 此情况有特殊情况，整个二叉树只有两个节点，删除的节点是根节点时，此时parent指向空，需要单独处理，否则会有空引用异常

情况三：删除的节点有两个子节点

  1. 找到targetNode以及parent
  2. 从targetNode的右子树中找到值最小的节点(或从左子树中找到值最大的节点)，将此节点的值存储在一个变量temp中
  3. 删除此节点
  4. targetNode.Value = temp

完整代码

using System;

namespace BinarySortTreeDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = { 7, 3, 10, 12, 5, 1, 9, 0 };
            //int[] arr = { 0, 1 };
            BinarySortTree bst = new BinarySortTree();

            for (int i = 0; i < arr.Length; i++)
            {
                bst.Add(new Node(arr[i]));
            }
            bst.InfixOrder();
            Console.WriteLine();
            bst.DeleteNode(0);
            bst.DeleteNode(1);
            bst.DeleteNode(3);
            bst.DeleteNode(12);
            bst.DeleteNode(10);
            bst.InfixOrder();
        }
    }

    class BinarySortTree
    {
        private Node Root;

        public void Add(Node node)
        {
            if (Root == null)
                Root = node;
            else
                Root.AddNode(node);
        }

        public void InfixOrder()
        {
            if (Root != null)
                Root.InfixOrder();
            else
                Console.WriteLine("Empty!");
        }

        //查找要删除的节点
        public Node Search(int value)
        {
            if (Root == null)
                return null;
            else
                return Root.Search(value);
        }

        //查找待删除结点的父节点
        public Node SearchParent(int value)
        {
            if (this.Root == null)
                return null;
            else
                return Root.SearchParent(value);
        }

        /// <summary>
        /// 1. 返回以node为根节点的二叉排序树的最小节点的值
        /// 2. 删除node为根节点的二叉排序树的最小节点
        /// </summary>
        /// <param name="node">传入节点，当作二叉排序树的根节点</param>
        /// <returns>返回以node为根节点的二叉排序树的最小节点的值</returns>
        public int DeleteRightTreeMin(Node node)
        {
            Node t = node;
            //循环查找左节点
            while (t.Left != null)
            {
                t = t.Left;
            }
            //此时 t指向最小节点
            DeleteNode(t.Value);
            return t.Value;
        }

        /// <summary>
        /// 1. 返回以node为根节点的二叉排序树的最大节点的值
        /// 2. 删除node为根节点的二叉排序树的最大节点
        /// </summary>
        /// <param name="node">传入节点，当作二叉排序树的根节点</param>
        /// <returns>返回以node为根节点的二叉排序树的最大节点的值</returns>
        public int DeleteLeftTreeMax(Node node)
        {
            Node t = node;
            while (t.Right != null)
            {
                t = t.Right;
            }
            DeleteNode(t.Value);
            return t.Value;
        }

        //删除节点
        public void DeleteNode(int value)
        {
            if (Root == null)
                return;

            //1.查找targetNode
            Node targetNode = Search(value);
            //如果没有找到要删除的节点
            if (targetNode == null)
                return;

            //如果当前二叉排序树只有一个节点
            if (Root.Left == null && Root.Right == null)
            {
                Root = null;
                return;
            }

            //查找targetNode的父节点
            Node parent = SearchParent(value);

            //情况一
            if (targetNode.Left == null && targetNode.Right == null)
            {
                //判断targetNode 是parent的Left还是Right
                if (parent.Left != null && parent.Left.Value == value)
                {
                    parent.Left = null;
                }
                else if (parent.Right != null && parent.Right.Value == value)
                {
                    parent.Right = null;
                }
            }
            else if (targetNode.Left != null && targetNode.Right != null)//情况三
            {
                // 从右子树找到值最小的节点并处理
                //int minVal = DeleteRightTreeMin(targetNode.Right);
                //targetNode.Value = minVal;

                //从左子树找到值最大的节点并处理
                int maxVal = DeleteLeftTreeMax(targetNode.Left);
                targetNode.Value = maxVal;
            }
            else  //余下的就是只有一颗子树的节点
            {
                //如果要删除的节点有左子节点
                if (targetNode.Left != null)
                {
                    if (parent != null)
                    {
                        //如果targetNode是parent的左子节点
                        if (parent.Left.Value == value)
                        {
                            parent.Left = targetNode.Left;
                        }
                        else
                        {
                            parent.Right = targetNode.Left;
                        }
                    }
                    else
                    {
                        Root = targetNode.Left;
                    }
                }
                else
                {
                    if (parent != null)
                    {
                        if (parent.Left.Value == value)
                        {
                            parent.Left = targetNode.Right;
                        }
                        else
                        {
                            parent.Right = targetNode.Right;
                        }
                    }
                    else
                    {
                        Root = targetNode.Right;
                    }
                }
            }

        }
    }

    class Node
    {
        public int Value { get; set; }
        public Node Left { get; set; }
        public Node Right { get; set; }

        public Node(int value)
        {
            this.Value = value;
        }

        /// <summary>
        /// 通过value查找对应节点
        /// </summary>
        /// <param name="value">希望查找的节点的value</param>
        /// <returns>如果查找到对应节点则返回，否则返回null</returns>
        public Node Search(int value)
        {
            if (value == this.Value)
                return this;
            else if (value < this.Value)  //查找的值小于当前节点
            {
                if (this.Left == null)
                    return null;
                else
                    return this.Left.Search(value);
            }
            else
            {
                if (this.Right == null)
                    return null;
                else
                    return this.Right.Search(value);
            }
        }

        /// <summary>
        /// 通过value查找对应节点的父节点
        /// </summary>
        /// <param name="value">带查找节点的value</param>
        /// <returns>如果查找到对应节点的父节点则返回，否则返回null</returns>
        public Node SearchParent(int value)
        {
            if ((this.Left != null && this.Left.Value == value) || (this.Right != null && this.Right.Value == value))
                return this;
            else
            {
                //如果查找的值，小于当前节点的值，并且当前节点的左子节点不为空
                if (value < this.Value && this.Left != null)
                {
                    return this.Left.SearchParent(value);
                }
                else if (value >= this.Value && this.Right != null)
                {
                    return this.Right.SearchParent(value);
                }
                else
                    return null;
            }

        }

        //添加节点
        public void AddNode(Node node)
        {
            if (node == null)
                return;

            //判断节点的值，与当前子树根节点的值的关系
            if (node.Value < this.Value)
            {
                //如果当前节点左子节点为null
                if (this.Left == null)
                    this.Left = node;
                else  //递归向左子树添加
                    this.Left.AddNode(node);
            }
            else  //node 的值大于等于当前节点的值
            {
                if (this.Right == null)
                    this.Right = node;
                else //递归向右处理
                    this.Right.AddNode(node);
            }
        }

        public void InfixOrder()
        {
            if (this.Left != null)
                this.Left.InfixOrder();
            Console.WriteLine(this);
            if (this.Right != null)
                this.Right.InfixOrder();
        }

        public override string ToString()
        {
            return $"Node: [value = {this.Value}]";
        }
    }
}
Roy Summy
关注
专栏目录
C#编写的二叉排序树
05-14
由c#编写的画二叉排序树、以及动态画二叉排序树，还有平均查找长度的计算、删除叶节点、查找节点的操作，是数据结构中挺重要的一部分。
二叉排序树BST
c梦的博客
02-04 159
What 二叉排序树BST： (Binary Sort Tree 或 Binary Search Tree), 对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。对于相同的值，可以放在左节点或右节点。 Why 对于数组： 如果数组有序，那么查找速度会很快O(lgn)（使用二分查找），但是增删会很慢（会整体移动数组的一部分会...
C# 二叉排序树
陈言必行 -- Unity游戏开发领域优质博主
12-24 691
二叉排序树，又称为二叉查找树。它或者是一颗空树，或者是具有下列性质的二叉树：
C#算法系列（3）——二叉排序树
午夜支枕听河流
11-27 1143
一、什么是二叉排序树       二叉排序树，又称为二叉查找树。它或者是一棵空树，或者具有下列性质的二叉树：        （1）若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；        （2）若它的右子树不空，则右子树上所有结点的值均大于它的根节点的值；        （3）它的左右子树分别为二叉排序树。        构造一棵二叉排序树的目的，其实并不是为了排序，而是
C#实现二叉排序树代码实例
12-31
二叉排序树，又称为二叉查找树。...C#链式存储二叉排序树，实现简单的排序，以及查找，具体代码如下： namespace _2_1_3二叉排序树 { /// /// 结点类 /// class BSNode { //结点 public BSNode Lef
C#实现二叉排序树详解及代码示例
"C# 实现二叉排序树的代码实例" 在计算机科学中，二叉排序树（Binary Sort Tree，又称二叉查找树）是一种特殊的二叉树数据结构，它具有以下特性： 1. 每个节点包含一个键（key）、一个关联的值、一个指向左子树的...
C#链式二叉排序树实现与代码示例
C#实现二叉排序树代码实例详细讲解了如何利用链式存储构建二叉查找树的数据结构。在C#编程语言中，二叉排序树（Binary Search Tree，BST）是一种特殊类型的二叉树，其节点遵循特定的规则：左子树中的所有节点值都...
二叉排序树的C#实现
weixin_30885111的博客
03-26 192
寒假回家的时候，看了一下C#语言描述版的数据结构。我只是单纯的想，更加熟悉计算机语言，我希望能像是用母语一样使用计算机语言和计算机交流。很奇怪之前学C语言版本的数据结构，那些算法我都不是非常理解，但在读这本书的时候，却有种豁然开朗的感觉。是书写的好还是我能力有所提高亦或是两者皆有？ 进入正题。 二叉排序树说起来其实并不是很难。二叉查找树是一种把值比较小的节点存储在左子节点内而值比较大的节点存储...
二叉排序树的实现（C#）
waterathena的专栏
10-09 1278
  搞了一天终于把这个homework搞定了。开心    ，下个星期有新的任务了。如果所有工作在星期五都可以告于一个段落，对所有职场人来说应该是一件很舒心的事吧。周末可以专注自己的其他事情，不用背着包袱过日子。Wish happy weekend!曾经在网上搜到很多关于一些数据结构的代码，对过往的我的学业带来很大帮助，对现在工作中的我也很有启发。所以现在也把代码共享出来。希望也可以he
数据结构C#篇(链表，二叉树，排序)
03-14
数据结构C#篇，数据结构的C#描述链表，二叉树，排序等常用数据结构
c#二叉排序树实现
jialeheyeshu的博客
12-02 1767
主要是二叉排序树的构建和显示 using System; using System.Collections; using System.Text; public class Node { public int data; public Node left; public Node right; public void DisplayNode() {
C#实现二叉排序树定义、插入、构造
weixin_41883890的博客
06-29 339
本文讲解C#实现二叉排序树定义、插入、构造 二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。是数据结构中的一类。在一般情况下，查询效率比链表结构要高。 步骤：若根结点的关键字值等于查找的关键字，成功。 否则，若小于根结点的关键字值，递归查左子树。 若大于根结点的关键字值，递归查右子树。 若子树为空，查找不成功。 平均情况分析（在成功查找两种的情况下）： 在一般情况下，设 P（n，i）为它的左子树的结点个数为 i 时的平均查找长度。结点个
c# 二叉树
alice_art的专栏
09-28 1092
 本程序中将用到一棵已知的二叉树如图（二叉树图）所示。先序遍历：1.       访问根结点2.       按先序遍历左子树;3.       按先序遍历右子树；4.       例如：遍历已知二叉树结果为：A->B->D->G->H->C->E->F中序遍历：1.       按中序遍历左子树;2.       访问根结点；3.       按中序遍历右子树
C#实现二叉树的各种遍历
weixin_30312557的博客
06-21 120
C#实现二叉树的各种遍历 1. 引言 在实际的项目中，树还是用的比较多的一种，尤其是对于具有层次结构的数据。相信很多人都学过树的遍历，比如先序遍历，后序遍历等，利用递归还是很容易理解的。 今天给大家介绍下二叉树的几种遍历算法，包括递归和非递归的实现。 首先建立...
C# 数据结构 之 二叉树
weixin_30263073的博客
08-28 262
二叉树的定义 二叉树(Binary Tree)是n(n>=0)个有限元素的集合，该集合或者为空，或者由一个称为根(root)的元素及两个不相交的，被称为左子树和右子树的二叉树组成。当集合为空时，称该二叉树为空二叉树，在二叉树中，一个元素也称为一个结点。 二叉树是有序的，即若将其左右子树颠倒，就称为另一颗不同的二叉树。 二叉树的相关术语 结点的度：结点所拥有的子树的个数称为该结点的度。...
C#算法设计排序篇之11-二叉树排序（附带动画演示程序）
热门推荐
比特飞
08-14 1万+
二叉树排序（Binary Tree Sort） 二叉树排序是构建在二叉排序树（Binary Sort Tree）上的算法，二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： 若左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值； 若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值； 左、右子树也分别为二叉排序树。 二叉树排序需要先生成一个二叉排序树，再使用中序遍历...
数据结构之二叉树（C#版）
jmelzc的博客
01-06 1995
数据结构之二叉树（C#版）简介代码实现总结 简介 代码实现 总结
排序二叉树C#实现
zhuweisky
07-02 2669
        很久以前写的，现在贴出来交流一下。先看排序二叉树的接口public interface ISorttedBinaryTree {  void InsertElement(IComparable val) ;//如果树中有一个节点的值等于val的值，则val将被忽略  void RemoveElement(IComparable val) ;  bool ContainsElemen
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值