C#实现二叉查找树以及二叉树的删除

最新推荐文章于 2023-02-02 16:25:44 发布
最新推荐文章于 2023-02-02 16:25:44 发布
阅读量465 收藏 3
点赞数
分类专栏： 数据结构与算法 C# 文章标签： 数据结构 二叉树 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzzsss123333/article/details/108013716
版权

C#实现二叉查找树以及二叉树的删除

首先需要知道二叉树的基础知识，比父节点小的元素放在左边，大的放在右边

一.实现二叉查找树

对二叉树进行遍历查找
没有找到返回-1
在这里插入图片描述

二.实现二叉树的节点删除

二叉树的节点删除难点就在于要分类讨论的地方太多了，容易混乱
1.前提是删除的节点得存在（使用上面提到的二叉查找树）
2.首先需要找到需要删除的节点
3.需要找到删除节点的父节点
代码实现如下
在这里插入图片描述
之后就需要分类进行讨论了
代码里面的注释非常的详细了
整体删除节点方法的代码如下

        public void Delete(int item)
        {
            if (FindItem(item) == -1)
                throw new Exception("删除的元素不在二叉树内");

            //当元素存在时
            else
            {
                //寻找到要删除的节点
                //寻找到要删除元素的父节点
                Node currNode = rootNode;
                Node parentNode = rootNode;
                //和寻找元素一样,只不过这次寻找的不是元素而是节点
                while (true)
                {
                    if (item < currNode.item)
                    {
                        parentNode = currNode;
                        currNode = currNode.leftNode;
                    }
                    else if (item > currNode.item)
                    {
                        parentNode = currNode;
                        currNode = currNode.rightNode;
                    }
                    else
                    {
                        //找到了退出循环
                        break;
                    }
                }
                /******下面进行分类讨论******/
                //1.当要删除的节点既没有左节点也没有右节点时
                if (currNode.leftNode == null && currNode.rightNode == null)
                {
                    /*这时还是有两种情况*/
                    //1.为叶子节点时
                    if (parentNode != currNode)
                    {
                        /*先判断是父节点的左孩子还是右孩子*/
                        //左边时
                        if (currNode.item < parentNode.item)
                            parentNode.leftNode = null;
                        //右边时
                        else
                            parentNode.rightNode = null;
                    }
                    //2.为根节点时
                    else
                    {
                        rootNode = null;
                    }
                }
                //2.当要删除的节点只有左节点时
                else if (currNode.leftNode != null && currNode.rightNode == null)
                {
                    /*先判断是父节点的左孩子还是右孩子*/
                    //左边时
                    if (currNode.item < parentNode.item)
                        parentNode.leftNode = currNode.leftNode;
                    //右边时
                    else if(currNode.item > parentNode.item)
                        parentNode.rightNode = currNode.leftNode;
                    else
                    {
                    	rootNode = currNode.leftNode;
                    }
                }
                //3.当要删除的节点只有右节点时
                else if (currNode.leftNode == null && currNode.rightNode != null)
                {
                    /*先判断是父节点的左孩子还是右孩子*/
                    //左边时
                    if (currNode.item < parentNode.item)
                        parentNode.leftNode = currNode.rightNode;
                    //右边时
                    else if(currNode.item > parentNode.item)
                        parentNode.rightNode = currNode.rightNode;
                   	else
                   	{
                   		rootNode = currNode.rightNode;
                   	}
                }
                //4.当删除的节点既有左又有右节点时
                else
                {
                    Node tmp=null;//暂时存储
                    /*先判断是父节点的左孩子还是右孩子*/
                    //左边时
                    if(currNode.item < parentNode.item)
                    {
                        parentNode.leftNode = currNode.leftNode;
                        tmp = currNode.rightNode;
                        while (currNode.leftNode != null)
                        {
                            currNode = currNode.leftNode;
                        }
                        currNode.rightNode = tmp;
                    }
                    //右边时
                    else if (currNode.item > parentNode.item)
                    {
                        parentNode.rightNode = currNode.rightNode;
                        tmp = currNode.leftNode;
                        while (currNode.rightNode!=null)
                        {
                            currNode = currNode.rightNode;
                        }
                        currNode.leftNode = tmp;
                    }
                    //为根节点时
                    else
                    {
                        rootNode = rootNode.rightNode;
                        tmp = currNode.leftNode;
                        while (currNode.rightNode != null)
                        {
                            currNode = currNode.rightNode;
                        }
                        currNode.leftNode = tmp;
                    }
                }
            }
        }

接下来我用中序遍历来测试结果

    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = { 5, 8, 3, 9, 6, 0, 4, 2, 1, 7 };
            MyTree myTree = new MyTree(arr);
            Console.WriteLine("寻找到的元素:"+myTree.FindItem(4));
            Console.WriteLine("删除前的中序遍历:");
            myTree.OrderShow(myTree.rootNode);
            Console.WriteLine();
            myTree.Delete(4);
            Console.WriteLine("删除后的中序遍历:");
            myTree.OrderShow(myTree.rootNode);
            Console.ReadKey();
        }
    }

在这里插入图片描述

最后是整体的代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp22
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] arr = { 5, 8, 3, 9, 6, 0, 4, 2, 1, 7 };
            MyTree myTree = new MyTree(arr);
            Console.WriteLine("寻找到的元素:"+myTree.FindItem(4));
            Console.WriteLine("删除前的中序遍历:");
            myTree.OrderShow(myTree.rootNode);
            Console.WriteLine();
            myTree.Delete(4);
            Console.WriteLine("删除后的中序遍历:");
            myTree.OrderShow(myTree.rootNode);
            Console.ReadKey();
        }
    }
    class Node
    {
        public Node leftNode;
        public Node rightNode;
        public int item;
        public Node(int item)
        {
            this.item = item;
            leftNode = null;
            rightNode = null;
        }
    }
    class MyTree
    {
        public Node rootNode;
        public MyTree(int[] arr)
        {
            for (int i = 0; i < arr.Length; i++)
            {
                AddNode2Tree(arr[i]);
            }
        }

        //建立二叉树
        private void AddNode2Tree(int item)
        {
            Node currNode = rootNode;
            if (rootNode == null)
            {
                rootNode = new Node(item);
                return;
            }
            while (true)
            {
                if (item < currNode.item)
                {
                    if (currNode.leftNode == null)
                    {
                        currNode.leftNode = new Node(item);
                        return;
                    }
                    else
                    {
                        currNode = currNode.leftNode;
                    }
                }
                else
                {
                    if (currNode.rightNode == null)
                    {
                        currNode.rightNode = new Node(item);
                        return;
                    }
                    else
                    {
                        currNode = currNode.rightNode;
                    }
                }
            }
        }
        //寻找二叉树中的元素
        public int FindItem(int item)
        {
            Node node = rootNode;
            while (true)
            {
                if (item == node.item)
                {
                    return node.item;
                }
                else if (item < node.item)
                {
                    node = node.leftNode;
                }
                else
                {
                    node = node.rightNode;
                }

                if (node == null)
                {
                    return -1;
                }
            }
        }
        //删除二叉树中的元素
        public void Delete(int item)
        {
            if (FindItem(item) == -1)
                throw new Exception("删除的元素不在二叉树内");

            //当元素存在时
            else
            {
                //寻找到要删除的节点
                //寻找到要删除元素的父节点
                Node currNode = rootNode;
                Node parentNode = rootNode;
                //和寻找元素一样,只不过这次寻找的不是元素而是节点
                while (true)
                {
                    if (item < currNode.item)
                    {
                        parentNode = currNode;
                        currNode = currNode.leftNode;
                    }
                    else if (item > currNode.item)
                    {
                        parentNode = currNode;
                        currNode = currNode.rightNode;
                    }
                    else
                    {
                        //找到了退出循环
                        break;
                    }
                }
                /******下面进行分类讨论******/
                //1.当要删除的节点既没有左节点也没有右节点时
                if (currNode.leftNode == null && currNode.rightNode == null)
                {
                    /*这时还是有两种情况*/
                    //1.为叶子节点时
                    if (parentNode != currNode)
                    {
                        /*先判断是父节点的左孩子还是右孩子*/
                        //左边时
                        if (currNode.item < parentNode.item)
                            parentNode.leftNode = null;
                        //右边时
                        else
                            parentNode.rightNode = null;
                    }
                    //2.为根节点时
                    else
                    {
                        rootNode = null;
                    }
                }
                //2.当要删除的节点只有左节点时
                else if (currNode.leftNode != null && currNode.rightNode == null)
                {
                    /*先判断是父节点的左孩子还是右孩子*/
                    //左边时
                    if (currNode.item < parentNode.item)
                        parentNode.leftNode = currNode.leftNode;
                    //右边时
                    else
                        parentNode.rightNode = currNode.leftNode;
                }
                //3.当要删除的节点只有右节点时
                else if (currNode.leftNode == null && currNode.rightNode != null)
                {
                    /*先判断是父节点的左孩子还是右孩子*/
                    //左边时
                    if (currNode.item < parentNode.item)
                        parentNode.leftNode = currNode.rightNode;
                    //右边时
                    else
                        parentNode.rightNode = currNode.rightNode;
                }
                //4.当删除的节点既有左又有右节点时
                else
                {
                    Node tmp=null;//暂时存储
                    /*先判断是父节点的左孩子还是右孩子*/
                    //左边时
                    if(currNode.item < parentNode.item)
                    {
                        parentNode.leftNode = currNode.leftNode;
                        tmp = currNode.rightNode;
                        while (currNode.leftNode != null)
                        {
                            currNode = currNode.leftNode;
                        }
                        currNode.rightNode = tmp;
                    }
                    //右边时
                    else if (currNode.item > parentNode.item)
                    {
                        parentNode.rightNode = currNode.rightNode;
                        tmp = currNode.leftNode;
                        while (currNode.rightNode!=null)
                        {
                            currNode = currNode.rightNode;
                        }
                        currNode.leftNode = tmp;
                    }
                    //为根节点时
                    else
                    {
                        rootNode = rootNode.rightNode;
                        tmp = currNode.leftNode;
                        while (currNode.rightNode != null)
                        {
                            currNode = currNode.rightNode;
                        }
                        currNode.leftNode = tmp;
                    }
                }
            }
        }
        //中序遍历
        public void OrderShow(Node rootNode)
        {
            if (rootNode != null)
            {
                OrderShow(rootNode.leftNode);
                Console.Write(rootNode.item);
                OrderShow(rootNode.rightNode);
            }
        }
    }
}

本篇文章参考:https://www.cnblogs.com/BrokenIce/p/5929169.html

[C++]---二叉搜索树简单实现(查找，插入，删除)
夜微雨的博客
02-28 1444
目录 二叉搜索树概念及特点 1.特点 二叉搜索树的简单操作 1.查找操作 2.插入操作 3.删除操作 二叉搜索树的性能分析 二叉搜索树概念及特点 1.特点 二叉搜索树又称二叉排序树，它可能是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别...
二叉查找树(BST)，平衡二叉树(AVL)，红黑树之间的区别
Linkai12138的博客
10-14 1613
1. 4者的区别与联系 二叉树，二叉查找树(BST)，平衡二叉树(AVL)，红黑树之间的区别： 根据百度百科给出的定义，它们之间的关系可以用下图表示，平衡二叉树（平衡二叉查找树，AVL）和红黑树都是二叉查找树的一种，区别就是平衡二叉树严格平衡，红黑树是弱平衡。 而AVL树由于实现比较复杂，而且插入和删除性能差，在实际环境下的应用不如红黑树。 2. 二叉查找树（BST） 2.1 定义 左子树的值小于根节点的值，右子树的值全部大于根节点的值；左右子树分别都是一颗二叉查找树。（递归定义） 3.1.2 缺点 可
排序二叉树节点的删除
diechi0288的博客
05-14 167
要点： 1.查找到被删除的节点 2.分析要删除的节点 　　1.叶子结点 　　2.有一个孩子 　　3.有两个孩子（根节点和其他节点） 代码实现： void SearchNode(Tree** pDel,Tree** pFather,int num) { while(*pDel) { if((*pDel)->val == num...
二叉树：删除二叉搜索树中的节点
最新发布
qq_43591406的博客
02-02 2155
然后开始从最底下一层往上传值，下面一层返回的值，其实是上面一个层函数的组成部分，同样，上面一层函数返回的值又是上上面一层函数的组成部分。那按照同样的思路，最底下一层调用递归函数传入的参数会是2这个结点的左子树，也就是。到这里就讲解完毕了，如果还是不明白，结合思路，代码，将这个例子自己理一遍思路。我们在组织代码的时候，脑子里要有向下寻找的过程，更要有一层一层向上回溯的过程。对于1，没找到，说明树不会被修改，将原来的树原封不动返回。对于2，找到了，肯定返回的是最终删除了指定元素的树。
二叉查找树查找，插入，删除算法详解（C语言实现，注释最全，单步调试通过）
ghxjk_6的博客
07-21 734
二叉查找树查找，插入，删除算法详解（C语言实现，注释最全，单步调试通过）二叉查找树的定义二叉查找树的实现 二叉查找树的定义 二叉排序树 (Binary Sort Tree) 又称二叉查找树，它是一种对排序和查找都很有用的特殊二叉树。 二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： (1) 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； (2) 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； (3) 它的左、 右子树也分别为二叉排序树。 二叉排序树是递归定义的。 由定义
二叉搜索树（展平、插入、查找、删除）
beautiful77moon的博客
11-05 233
删除： 1. 删除的节点为叶子节点：直接删除 2. 删除的节点只有左子树或只有右子树：将其子树的根节点替换此节点 3. 删除的节点既有左子树又有右子树：用其右子树的最小节点代替，然后将代替的节点删除（这个代替的节点分为其为叶子节点和只有右子树两种情况） # 节点的定义 class BiTreeNode: def __init__(self,data): self.data=data self.lchild=None self.rchild=N
C#实现二叉排序树代码实例
12-31
二叉排序树，又称为二叉查找树。...C#链式存储二叉排序树，实现简单的排序，以及查找，具体代码如下： namespace _2_1_3二叉排序树 { /// /// 结点类 /// class BSNode { //结点 public BSNode Lef
C#创建二叉搜索树的方法
09-03
二叉搜索树（Binary Search Tree，BST）是一...通过这种方式创建的二叉搜索树，能够保持查找、插入和删除操作的时间复杂度为O(log n)，其中n是树中节点的数量。在实际应用中，二叉搜索树常被用于高效地存储和检索数据。
C#实现二叉排序树详解及代码示例
这个C#实现的二叉排序树代码实例可以作为学习和理解二叉查找树概念的一个起点。通过这个基础，你可以扩展它以实现查找、删除和其他高级功能，如平衡二叉排序树（如AVL树或红黑树），以提高在极端情况下的性能。
二叉树的c#实现 包括添加删除
06-24
带登陆界面 前序中序实现二叉树 可动态实现
C# 树的实现，支持删除添加节点
03-12
通过借鉴此代码实现，可以在此基础上来找到自己所需要的功能实现方法
C# 二叉树的综合操作（二）：删除节点
Rondapapi的博客
12-28 1720
删除二叉树的节点相对复杂一些。 要分为三种情况：（1）要删除的节点为叶子节点，即此节点没有子节点；（2）要删除的节点只有一个子节点；（3）要删除的节点有两个子节点。其中每种情况又要细分为同种情况：要删除的节点是其父节点的左子节点，以及，要删除节点是其父节点的右子节点。     删除操作需要用到上一章说的到的“查找方法”。将上一章的代码加入 Delete（int key）方法，完事代码好 p
二叉树~删除节点
qq_45058113的博客
04-14 2154
要求： 1）如果删除的是叶子节点，则删除叶子节点 2）如果删除的是非叶子节点，则删掉整个子树 3）测试，删掉3号和5号节点 思路： 首先考虑： 考虑如果树是空树，如果只有一个root节点，那么等价于将整个二叉树置空 然后进行下面操作 1）因为二叉树是单向的，所以我们是判断当前节点的子节点是否需要删除节点，而不能判断当前这个节点上是不是需要删除的节点 2）如果当前节点的左子节点不为空，且左子节点就是要删除的节点，就将this.left == null;并且返回（结束递归） 3) 如果当
C#二叉树的删除，获取，清空操作
qq_24391357的博客
05-10 989
看过上一篇的朋友这篇应该很容易懂。我就不多说了，随便提一下就好了。。不懂的可以先看看上一篇：二叉树的插入操作删除：      需要注意的是我们节点个数的变化，因为我们删除的有可能不是一个节点而是一棵子树，那么我们节点树应该怎么算呢？？？我们先来看看代码：public void DeleteNode(Btree t, uint pos, int count)        {            ...
二叉排序树的查找、插入、删除（C#实现）
codingandilearning的博客
04-18 662
//用二叉链表结构构造二叉排序树 class TreeNode//树的结点 { public int key; public string treeNodeName; public TreeNode lChild, rChild; } class BiTree//二叉树 { public TreeNo...
450. 删除二叉搜索树中的节点
欢迎来到我的博客，在这里我会用我的方式来讲解知识，请大家多多关照
01-15 722
难度中等1037给定一个二叉搜索树的根节点和一个值，删除二叉搜索树中的对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。另一个正确答案是 [5,2,6,null,4,null,7]。二叉树不包含值为 0 的节点[][0, 104]root要求算法时间复杂度为 O(h)，h 为树的高度。
二叉树-删除节点
qq_30657195的博客
06-03 555
要求 如果删除的节点是叶子节点，则删除该节点。 如果删除的节点是非叶子节点，则删除树。 测试 删除5号叶子节点和3号树。 代码实现 package chapter18.binarytree object BinaryTreeDemo { def main(args: Array[String]): Unit = { //先使用比较简单的方法，直接关联 val root = new HeroNode(1, "宋江") val hero2 = new HeroNode(2,
C#数据结构与算法学习笔记 删除树中元素，计算树的最大高度
Mr_Tfos的博客
05-23 229
1.删除最大和最小元素 找到最小值、最大值： public E Min() { if (IsEmpty) throw new ArgumentException("空树！"); return Min(root).e; } //返回以node为根的二叉查找树的最小值所在的节点 private Node Min(Node node)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值