C# 二叉树的实现

最新推荐文章于 2024-03-14 13:05:02 发布
最新推荐文章于 2024-03-14 13:05:02 发布
阅读量85 收藏
点赞数
文章标签： c# 数据结构与算法
原文链接：http://www.cnblogs.com/liuling2010/archive/2010/12/05/cocoliu.html
版权

闲来无事，最近用C#实现了数据结构的二叉树 其中包括排序二叉树的实现。

首先来看一下二叉树节点的实现

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


namespace LinkBiTree
{
    public class BiTreeNode<T> where T:IComparable<T>
    {
        //定义数据域
        private T data;
        //定义二叉树的左孩子节点
        private BiTreeNode<T> lChild;
        //定义右孩子节点
        private BiTreeNode<T> rChild;

        //构造函数
        //含三参的构造函数
        public BiTreeNode(T val,BiTreeNode<T> lc,BiTreeNode<T> rc)
        {
            data = val;
            lChild = lc;
            rChild = rc;
        }
        //含俩参的构造函数
        public BiTreeNode(BiTreeNode<T> lc, BiTreeNode<T> rc)
        {
            data=default(T);
            lChild = lc;
            rChild = rc;
        }
        //含一参的构造函数
        public BiTreeNode(T val)
        {
            data = val;
            lChild = null;
            rChild = null;
        }
        //无参的构造函数
        public BiTreeNode()
        {
            data = default(T);
            lChild = null;
            rChild = null;
        }

        //数据域属性
        public T Data
        {
            get
            {
                return data;
            }

            set
            {
                data = value;
            }
        }

        //左孩子域
        public BiTreeNode<T> LChild
        {
            get
            {
                return lChild;
            }
            set
            {
                lChild = value;
            }
        }
        //右孩子域属性
        public BiTreeNode<T> RChild
        {
            get
            {
                return rChild;
            }
            set
            {
                rChild = value;
            }
        }
 
    }
}

接着来看二叉树的定义和基本运算的实现

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

namespace LinkBiTree
{
    public class LinkBiTree<T> where T : IComparable<T>
    {
        //头引用字段
        private BiTreeNode<T> head;
        //头引用属性
        public BiTreeNode<T> Head
        {
            get
            {
                return head;
            }
            set
            {
                head = value;
            }
        }

        //构造函数
        //不含参数的构造函数
        public LinkBiTree()
        {
            head = null;
        }
        //含一个参数的构造函数
        public LinkBiTree(T val)
        {
            BiTreeNode<T> p = new BiTreeNode<T>(val);
            head = p;
        }
        //含三参数的构造函数
        public LinkBiTree(T val, BiTreeNode<T> lc, BiTreeNode<T> rc)
        {
            BiTreeNode<T> p = new BiTreeNode<T>(val, lc, rc);
            head = p;
        }

        // 二叉树判空
        public bool IsEmpty()
        {
            if (head == null)
            {
                return true;
            }
            else
            {
                return false;
            }
        }


        //获取根节点
        public BiTreeNode<T> Root()
        {
            return head;
        }

        //获取节点的左孩子
        public BiTreeNode<T> GetLChild(BiTreeNode<T> p)
        {
            return p.LChild;
        }

        //获取节点的右孩子
        public BiTreeNode<T> GetRChild(BiTreeNode<T> p)
        {
            return p.RChild;
        }


        //将节点p的左子树插入值为val的新节点，原来的左子树成为新节点的左子树
        public void InsertLChlid(T val, BiTreeNode<T> p)
        {
            BiTreeNode<T> temp = new BiTreeNode<T>(val);
            temp.LChild = p.LChild;
            p.LChild = temp;
        }


        //排序插入函数
        public void SortInsert(T newItem,BiTreeNode<T> p)
        {
            if (p.Data.CompareTo(newItem)>0)
            {
                if (p.LChild == null)
                {
                    p.LChild = new BiTreeNode<T>(newItem);
                }
                else
                {
                    SortInsert(newItem, p.LChild);
                }
            }
            else
            {
                if (p.RChild == null)
                {
                    p.RChild = new BiTreeNode<T>(newItem);
                }
                else
                {
                    SortInsert(newItem, p.RChild);
                }
            }

        }

        //将节点p的右子树插入值为val的新节点，原来的右子树成为新节点的右子树

        public void InsertRChild(T val, BiTreeNode<T> p)
        {
            BiTreeNode<T> temp = new BiTreeNode<T>(val);
            temp.RChild = p.RChild;
            p.RChild = temp;
        }

        //若p非空 删除节点p的左子树 并将删除的左子树返回
        public BiTreeNode<T> DeleteLChild(BiTreeNode<T> p)
        {
            if ((p == null) || (p.LChild == null))
            {
                return null;
            }

            BiTreeNode<T> temp = p.LChild;
            p.LChild = null;
            return temp;
        }

        //若p非空 删除节点p的右子树 并将删除的右子树返回
        public BiTreeNode<T> DeleteRChild(BiTreeNode<T> p)
        {
            if ((p == null) || (p.RChild== null))
            {
                return null;
            }

            BiTreeNode<T> temp = p.RChild;
            p.RChild = null;
            return temp;
        }

        //在二叉树中查找值为val的节点
        public BiTreeNode<T> Search(BiTreeNode<T> Root, T val)
        {
            BiTreeNode<T> p = Root;

            if (p == null)
            {
                return null;
            }

            if (p.Data.Equals(val))
            {
                return p;
            }
            //递归求左子树
            if (p.LChild != null)
            {
                return Search(p.LChild, val);
            }
            //递归求右子树
            if(p.RChild!=null)
            {
                return Search(p.RChild ,val);
            }

            return null;
        }


        //判断是否为叶子节点
        public bool IsLeaf(BiTreeNode<T> p)
        {
            if ((p != null) && (p.LChild == null) && (p.RChild == null))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

    }
}

 

 

排序二叉树的测试程序

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using LinkBiTree;

namespace SortedBiTreeVisit
{
    class Program
    {
        public static StringBuilder SortedBiTreestr=new StringBuilder();
        //排列二叉树的遍历
      
        public static string SortedBiTreeVisit(BiTreeNode<int> p)
        {
            if (p.LChild != null)
            {
                SortedBiTreeVisit(p.LChild);
            }
            SortedBiTreestr.Append(p.Data.ToString()+" ");
            if (p.RChild != null)
            {
                SortedBiTreeVisit(p.RChild);
            }
            return SortedBiTreestr.ToString();
        }
        static void Main(string[] args)
        {
            LinkBiTree<int> li = new LinkBiTree<int>(1);
            li.SortInsert(23,li.Head);
            li.SortInsert(66, li.Head);
            li.SortInsert(17, li.Head);
            li.SortInsert(12, li.Head);
            li.SortInsert(19, li.Head);
            string result=SortedBiTreeVisit(li.Head);
            Console.WriteLine(result);
            Console.ReadKey();


        }
    }
}

 

二叉树的遍历测试程序

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using LinkBiTree;

namespace BiTreeVisit
{
    class Program
    {
        //用来存储遍历的数据
        public static  StringBuilder PreOderstr = new StringBuilder();
        public static StringBuilder MidOderstr = new StringBuilder();
        public static StringBuilder AftOderstr = new StringBuilder();
        public static StringBuilder LevOderstr = new StringBuilder();
        //保存叶子节点的个数
        public static int leafcount = 0;

        //保存二叉树深度
        左子树
        //public static int LBiTreeHeight = 1;
        右子树
        //public static int RBiTreeHeight = 1;

        //先序遍历递归算法
        public static string PreOrder(BiTreeNode<string> p )
        {
           
            if (p!= null)
            {
                PreOderstr.Append(p.Data+" ");
                PreOrder(p.LChild);
                PreOrder(p.RChild);

            }

            return PreOderstr.ToString();
        }

        //中序遍历递归算法
        public static string MidOrder(BiTreeNode<string> p)
        {

            if (p != null)
            {
                MidOrder(p.LChild);
                MidOderstr.Append(p.Data + " ");
                MidOrder(p.RChild);

            }

            return MidOderstr.ToString();
        }

        //后序遍历递归算法
        public static string AftOrder(BiTreeNode<string> p)
        {

            if (p != null)
            {
                AftOrder(p.LChild);
                AftOrder(p.RChild);
                AftOderstr.Append(p.Data + " ");

            }

            return AftOderstr.ToString();
        }

        //层次遍历
        public static string LevOrder(BiTreeNode<string> p)
        {
            if (p == null)
            {
                return null;
            }

            Queue<BiTreeNode<string>> sq = new Queue<BiTreeNode<string>>();
            sq.Enqueue(p);
            //循环层次遍历
            while (sq.Count > 0)
            {
                //节点出队列
                BiTreeNode<string> temp = sq.Dequeue();
                //将出队列的节点加入到字符串中
                LevOderstr.Append(temp.Data + " ");
                //将出队列的节点的左孩子加入队列
                if (temp.LChild != null)
                {
                    sq.Enqueue(temp.LChild);
                }
                //将出队列的节点的右孩子加入队列
                if (temp.RChild!=null)
                {
                    sq.Enqueue(temp.RChild);
                }
            }
            return LevOderstr.ToString();
        }

 

        //计算二叉树的叶子结点个数
        public static int CalCount(BiTreeNode<string> p)
        {
            if (p == null)
            {
                return 0;
            }

            Queue<BiTreeNode<string>> sq = new Queue<BiTreeNode<string>>();
            sq.Enqueue(p);
            //循环层次遍历
            while (sq.Count > 0)
            {
                //节点出队列
                BiTreeNode<string> temp = sq.Dequeue();
                //将出队列的节点加入到字符串中
                LevOderstr.Append(temp.Data + " ");
                if ((temp.LChild == null) && (temp.RChild == null))
                {
                    leafcount += 1;
                }
                //将出队列的节点的左孩子加入队列
                if (temp.LChild != null)
                {
                    sq.Enqueue(temp.LChild);
                }
                //将出队列的节点的右孩子加入队列
                if (temp.RChild != null)
                {
                    sq.Enqueue(temp.RChild);
                }
            }
            return leafcount;
        }

        //求二叉树深度
        public static int CalBitTreeHeight(BiTreeNode<string> p)
        {
            //定义局部变量保存左子树深度和右子树深度
            int LBiTreeHeight;
            右子树
            int RBiTreeHeight ;
            if (p == null)
            {
                return 0;
            }
            else
            {
                //
                LBiTreeHeight=CalBitTreeHeight(p.LChild);
                //
                RBiTreeHeight = CalBitTreeHeight(p.RChild);
            }

            if (LBiTreeHeight >= RBiTreeHeight)
                return (LBiTreeHeight + 1);
            else
                return (RBiTreeHeight + 1);
        }


        //测试函数
        static void Main(string[] args)
        {
            //初始化二叉树
            LinkBiTree<string> p = new LinkBiTree<string>("A");
            //建立二叉树
            BiTreeNode<string> temp = p.Head;
            temp.LChild = new BiTreeNode<string>("B");
            temp.RChild = new BiTreeNode<string>("C");
            temp.LChild.LChild = new BiTreeNode<string>("D");
            temp.LChild.RChild = null;
            temp.RChild.LChild = new BiTreeNode<string>("E");
            temp.RChild.RChild = new BiTreeNode<string>("F");
            temp.LChild.LChild.LChild = null;
            temp.LChild.LChild.RChild = new BiTreeNode<string>("G");

 

            //显示初始化的二叉树
            Console.WriteLine("初始化的二叉树为：");
            Console.WriteLine();
            Console.WriteLine(" " + " " + " " + " " + "A");
            Console.WriteLine(" " + " " + " " + " " + "*");
            Console.WriteLine(" " + " " + " " + "*" + " " + "*");
            Console.WriteLine(" " + " " + "*" + " " + " " + " " + "*");
            Console.WriteLine(" " + " " + "B" + " " + " " + " " + "C");
            Console.WriteLine(" " + " " + "*" + " " + " " + " " + "*");
            Console.WriteLine(" " + "*" + " " + " " + " " + "* " + " " + "*");
            Console.WriteLine("*" + " " + " " + " " + "*" + " " + " " + " " + " " + "*");
            Console.WriteLine("D" + " " + " " + " " + "E" + " " + " " + " "+ " " +"F");
            Console.WriteLine("*");
            Console.WriteLine(" " + "*");
            Console.WriteLine(" " + " "+"*");
            Console.WriteLine(" " + " " +  "G");
            Console.WriteLine("-------------------------------------------------------------------");


            Console.WriteLine("先序遍历的结果为：");
            string prestring = Program.PreOrder(p.Head);
            Console.WriteLine(prestring);

            Console.WriteLine("-------------------------------------------------------------------");


            Console.WriteLine("中序遍历的结果为：");
            prestring = Program.MidOrder(p.Head);
            Console.WriteLine(prestring);


            Console.WriteLine("-------------------------------------------------------------------");


            Console.WriteLine("后序遍历的结果为：");
            prestring = Program.AftOrder(p.Head);
            Console.WriteLine(prestring);
           


            Console.WriteLine("-------------------------------------------------------------------");


            Console.WriteLine("层次遍历的结果为：");
            prestring = Program.LevOrder(p.Head);
            Console.WriteLine(prestring);
        


            Console.WriteLine("-------------------------------------------------------------------");


            Console.WriteLine("叶子节点的个数为：");
            int conut =Program.CalCount(p.Head);
            Console.WriteLine(conut.ToString());


            Console.WriteLine("-------------------------------------------------------------------");


            Console.WriteLine("二叉树的深度为：");
            conut = Program.CalBitTreeHeight(p.Head);
            Console.WriteLine(conut.ToString());
         

 

 

            Console.ReadKey();
        }
    }
}

 

首次写博客 就写这么多吧 也算是留个脚印 ^_^

转载于:https://www.cnblogs.com/liuling2010/archive/2010/12/05/cocoliu.html

weixin_33743880
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构_线索二叉树(C语言)
小黯
08-09 919
线索二叉树 1. 结构解析 线索二叉树，是一种对链式结构的一般二叉树进行线索的二叉树，其线索过程其实就是对一般二叉树空指针的修改； 例如我们按中序顺序，使左空指针指向前驱结点(上一个结点)，右空指针指向后继结点(下一个结点)，最后所形成的二叉树也就是线索二叉树。 结构如图 Lchild和Rchild分别表示左右指针域，LTag和RTag分别标志其左右指针是否为空。 中序线索二叉树例图 2. 源代码: #include<stdio.h> #include<stdlib.h>
文兄的算法题——算术表达式递归构造二叉树
码农的试验田
12-22 916
正在奋斗天津大学的文兄前两天在做算法的时候遇到了一道棘手的题目。 当然，以文兄的聪明才智都不好解决的，我看着也一脸懵逼。然而有万能的度娘，最后还是找到了解决方案。然而说的不是很详细，这里给出我和文兄对这道题的一点理解。原题如下按照我的思路，应该先把算术表达式转换成后缀表达式， 那么（a+b）(c+d) 转换成后缀表达式为 ab + cd + 用栈存储运算符，用队列存储数—–然后看过HTDP
C#写算法之二叉树
最新发布
kk1kk2kk3kk4的博客
03-14 157
在数据结构中，树的定义如下：树(tree)是n(n>=0)个节点的有限集，当n=0时，称为空树。在任意一个非空树中，有如下特点：有且仅有一个特定的称为根的节点。当n>1时，其余节点可分为m(m>0)个互不相交的有限集，每一个集合本身又是一个树，并称为根的子树。树有以下概念：根节点、父节点、兄弟节点、孩子节点。树的最大层级数，被称为树的高度或深度。
简单算术表达式二叉树的构建和求值
weixin_74095289的博客
05-06 1028
步骤 将array[Maxsize]分为两部分，一部分为存粹的数字，一部分为存粹的符号得到数字figure[Maxsize]和symbol[Maxsize](由于此时数字大小为0到9，不需要另外转换，也因此可以设置这种类型的二叉树节点，否则需要在此时的二叉树节点上加上int 类型。假如是加减法，那么我们就申请一个Node节点用来存储+，-符号，并且将上一次进栈的值出栈，和此时的Node节点构成一个全新的二叉树，然后将新的head节点进栈。步骤 如果不是我们就依据此节点的符号，返回左右子树做*/+-后的值。
二叉树遍历的递归与非递归实现
网世的博客
11-23 213
主类 public class BiTreeOrderTest { //主类 public static void main(String[] args) { LinkBiTree tree = new LinkBiTree();//创建二叉树 createtree(tree); System.out.println("递归调用"); System.
关于c#二叉树的实现
09-05
本篇文章小编为大家介绍，关于c#二叉树的实现。需要的朋友参考下
C#二叉树递归实现
11-09
VS.net C# 二叉树递归实现 源码
C#动态实现二叉树
06-04
在C#编程中，动态实现二叉树是一种常见的数据结构操作，它允许程序在运行时创建、修改和遍历二叉树。二叉树是一种非线性数据结构，由节点（或称为顶点）和边构成，每个节点最多有两个子节点，通常称为左子节点和右子...
数据结构C#二叉树的基本运算
06-14
本话题主要聚焦于使用C#语言实现二叉树的基本运算，以下是对这些概念的详细阐述： 二叉树是由n（n>=0）个有限节点组成一个具有层次关系的集合。习惯上规定，除根节点外，每个节点有且仅有一个父节点，但可以有零个...
二叉树 各种遍历算法 C#实现
07-22
二叉树 各种遍历算法 C#实现
用c#编写的二叉树的图形化显示
05-27
这是一个用c#编写的windows应用程序，写的是二叉树在windows窗体上的生成显示
用C#实现的二叉树（窗体应用程序）
04-21
一个用C#写的简单的二叉树，可以创建、前序遍历、中序遍历、后续遍历。Windows 窗体应用程序。
【数据结构】二叉树链式结构实现_BiTreeLink
博客
11-14 4975
#include "string.h" #include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h" #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE
C# 数据结构 之 二叉树
weixin_30263073的博客
08-28 231
二叉树的定义 二叉树(Binary Tree)是n(n>=0)个有限元素的集合，该集合或者为空，或者由一个称为根(root)的元素及两个不相交的，被称为左子树和右子树的二叉树组成。当集合为空时，称该二叉树为空二叉树，在二叉树中，一个元素也称为一个结点。 二叉树是有序的，即若将其左右子树颠倒，就称为另一颗不同的二叉树。 二叉树的相关术语 结点的度：结点所拥有的子树的个数称为该结点的度。...
数据结构----二叉树（C#实现）
Elevenoo的博客
03-06 324
该帖只做笔记使用 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- 构建树的类Tree.cs 初始化树 ...
C# 实现的一个二叉树类
欲穷千里目，更上一层楼
03-01 5125
原文地址 http://www.cnblogs.com/ppchouyou/archive/2008/07/18/1245819.html 昨天用C#写了一个二叉树的类，包括如何构造二叉树的根节点，向二叉树中插入一个节点顺便实现了一下二叉树的四种遍历方法：前序，中序，后序，逐层。前三种方法用了递归的方式，后一种方法用了一个链表来解决中间数据的存储问题。感觉这个东东确实包含了不少值得回味的东西
数据结构:二叉树的建立和遍历(C#实现)
My diary
12-12 7502
遍历只做了先序,递归实现的,中序和后序都类似.代码比较简单,就不写注释,直接贴出来了 代码:TreeNode:结点类 using System;using System.Collections.Generic;using System.Text;namespace 二叉树的建立和遍历{    class TreeNode    {    
c# 二叉树代码
06-02
以下是C#中二叉树的基本实现代码： ```csharp using System; public class Node { public int value; public Node left; public Node right; public Node(int value) { this.value = value; left = null; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值