C#算法系列（1）——二叉树

最新推荐文章于 2025-06-18 14:49:49 发布
最新推荐文章于 2025-06-18 14:49:49 发布
阅读量7.9k 收藏 68
点赞数 19
CC 4.0 BY-SA版权
分类专栏： C# 文章标签： 二叉树 算法 遍历 存储 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_24642743/article/details/78597219
本文介绍二叉树的顺序存储与链式存储方法，并给出先序、中序、后序及层次遍历的实现代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

       本文主要讲述二叉树的两种创建方式与四种遍历方式，以及附上具体的实现代码。
       两种创建方式分别为：顺序存储和链式存储。遍历方式有：先序遍历、中序遍历、后序遍历以及层次遍历。

一、 二叉树的性质

       介绍性质主要是为了后续进行编写二叉树遍历算法的时会用到。

  1. 在二叉树的第i层上至多有2^(i-1)个结点（i≥1）。
  2. 深度为k的二叉树至多有2^k -1 个结点(k≥1)。
  3. 对任何一棵二叉树T，如果其终端结点数为n0，度为2的结点数为n2，则n0 = n2 +1。
    推导如下：
    分支总数 = 总节点数 - 1（1）
    分支总数 = 1*n1 + 2* n2 （n1表示度为1的结点数，n2表示度为2的结点数）（2）
    总节点数 = n0 + n1 + n2 （3）
    由（1），（2），（3）式即可得出n2 = n0 -1.
  4. 具有n个结点的完全二叉树的深度为log2 (n) + 1。
  5. 如果对一棵有n个结点的完全二叉树（其深度为log2 (n) + 1）的结点按层序编号，对任一结点i(1≤i≤n)有:
    （1）如果i=1,则结点i是二叉树的根，无双亲；如果i>1，则起双亲是结点i/2。
    （2）如果2i>n，则结点i无左孩子。
    （3）如果2i+1>n,则结点i无右孩子；否则其右孩子是结点2i+1。

二、二叉树的构建

（1）顺序存储：用数组进行保存
（2）链式存储：用两块指针域进行保存，主要思想是采用双向链表的思想

三、二叉树的具体实现

(1)顺序存储的具体实现：

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

namespace 二叉树_顺序存储
{
    //如果存储结点为空，用-1进行表示
    class BinaryTree<T>
    {
        private T[] data;
        private int count = 0; //当前二叉树保存的数据多少个
        /// <summary>
        /// 构造方法
        /// </summary>
        /// <param name="capacity">当前二叉树的容量</param>
        public BinaryTree(int capacity)
        {
            data = new T[capacity];
        }

        //添加元素
        public bool Add(T item)
        {
            if (count >= data.Length)
                return false;
            data[count] = item;
            count++;
            return true;
        }

        public void FirstTraversal()
        {
            FirstTraversal(0);
        }

        //先序遍历
        private void FirstTraversal(int index)
        {
            //递归的终止条件
            if (index >= count || data[index].Equals(-1))
                return;
            int number = index + 1; //下标是从0开始
            Console.Write(data[index] + " ");
            int leftNumber = number * 2;
            int rightNumber = number * 2 + 1;
            FirstTraversal(leftNumber-1);
            FirstTraversal(rightNumber-1);
        }

        public void MiddleTraversal()
        {
            MiddleTraversal(0);
        }

        //中序遍历
        private void MiddleTraversal(int index)
        {
            //递归的终止条件
            if (index >= count || data[index].Equals(-1))
                return;
            int number = index + 1; //下标是从0开始
            int leftNumber = number * 2;
            int rightNumber = number * 2 + 1;
            MiddleTraversal(leftNumber - 1);
            Console.Write(data[index] + " ");
            MiddleTraversal(rightNumber - 1);
        }

        public void LastTraversal()
        {
            LastTraversal(0);
        }

        //后序遍历
        private void LastTraversal(int index)
        {
            //递归的终止条件
            if (index >= count|| data[index].Equals(-1))
                return;
            int number = index + 1; //下标是从0开始
            int leftNumber = number * 2;
            int rightNumber = number * 2 + 1;
            LastTraversal(leftNumber - 1);
            LastTraversal(rightNumber - 1);
            Console.Write(data[index] + " ");
        }

        //层次遍历
        public void LayerTraversal()
        {
            for (int i = 0; i < count; i++)
            {
                if (data[i].Equals(-1))
                    continue;
                Console.Write(data[i] + " ");
            }
        }
    }
}

主函数测试类Program.cs：

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

namespace 二叉树_顺序存储
{
    class Program
    {
        static void Main(string[] args)
        {
            char[] data = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J' };
            BinaryTree<char> tree = new BinaryTree<char>(10);

            for (int i = 0; i < data.Length; i++)
            {
                tree.Add(data[i]);
            }
            Console.Write("先序遍历：");
            tree.FirstTraversal();
            Console.WriteLine();
            Console.Write("中序遍历：");
            tree.MiddleTraversal();
            Console.WriteLine();
            Console.Write("后序遍历：");
            tree.LastTraversal();
            Console.WriteLine();
            Console.Write("层次遍历：");
            tree.LayerTraversal();
            Console.ReadKey();
        }
    }
}

实验结果运行图：


这里写图片描述

（2）链式存储具体实现方式：
首先需要定义一个二叉树的结点类TreeNode.cs，具体代码如下：

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

namespace 二叉树_链式存储
{
    //二叉树结点类
    class TreeNode<T>
    {
        private T data; //数据域
        private TreeNode<T> lChild; //左孩子
        private TreeNode<T> rChild; //右孩子

        public T Data
        {
            get { return data; }
            set { data = value; }
        }

        public TreeNode<T> LChild
        {
            get { return lChild; }
            set { lChild = value; }
        }

        public TreeNode<T> RChild
        {
            get { return rChild; }
            set { rChild = value;}
        }

        public TreeNode()
        {
            data = default(T);
            lChild = null;
            rChild = null;
        }

        public TreeNode(T val)
        {
            data = val;
            lChild = null;
            rChild = null;
        }
    }
}

再定义一个二叉树类BinaryTree.cs

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

namespace 二叉树_链式存储
{
    class BinaryTree<T>
    {
        private TreeNode<T> head; //头指针
        private T[] datas; //用于构造二叉树的字符串
        public TreeNode<T> Head
        {
            get { return head; }
        }

        //创建二叉树
        public BinaryTree(T[] vals)
        {
            datas = vals;
            Add(head,0); //给头结点添加孩子节点
        }

        //使用先序创建二叉树 #:表示该位置无节点
        private void Add(TreeNode<T> parent, int index)
        {
            if (parent == null)
            {
                parent = new TreeNode<T>(datas[index]);
                head = parent;
            }

            int leftIndex = 2 * index + 1; //计算当前结点左孩子的索引
            int rightIndex = 2 * index + 2; //计算当前结点右孩子的索引

            if (leftIndex < datas.Length)
            {
                if (!datas[leftIndex].Equals("#"))
                {
                    parent.LChild = new TreeNode<T>(datas[leftIndex]);
                    Add(parent.LChild, leftIndex);
                }
                else
                {
                    parent.LChild = null;
                }
            }
            if (rightIndex < datas.Length)
            {
                if (!datas[rightIndex].Equals("#"))
                {
                    parent.RChild = new TreeNode<T>(datas[rightIndex]);
                    Add(parent.RChild, rightIndex);
                }
                else
                {
                    parent.RChild = null;
                }
            }
        }

        //先序遍历
        public void PreTraversal(TreeNode<T> node)
        {
            if (node != null)
            {
                Console.Write(node.Data + " ");
                PreTraversal(node.LChild);
                PreTraversal(node.RChild);
            }
        }

        //中序遍历
        public void InTraversal(TreeNode<T> node)
        {
            if (node != null)
            {
                InTraversal(node.LChild);
                Console.Write(node.Data + " ");
                InTraversal(node.RChild);
            }
        }

        //后序遍历
        public void LastTraversal(TreeNode<T> node)
        {
            if (node != null)
            {
                LastTraversal(node.LChild);
                LastTraversal(node.RChild);
                Console.Write(node.Data + " ");
            }
        }

        //层次遍历
        //引入队列
        public void LevelTranversal(TreeNode<T> node)
        {
            if (node == null)
            {
                return;
            }
            Queue<TreeNode<T>> queue = new Queue<TreeNode<T>>();
            queue.Enqueue(node);
            while (queue.Count > 0)
            {
                //结点出队
                TreeNode<T> temp = queue.Dequeue();
                Console.Write(temp.Data+" ");
                if (temp.LChild != null)
                {
                    queue.Enqueue(temp.LChild);
                }
                if (temp.RChild != null)
                {
                    queue.Enqueue(temp.RChild);
                }
            }
        }
    }
}

最后，主函数测试类Program.cs：

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

namespace 二叉树_链式存储
{
    class Program
    {
        static void Main(string[] args)
        {
            char[] data = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J' };
            BinaryTree<char> tree = new BinaryTree<char>(data);
            Console.Write("先序遍历：");
            tree.PreTraversal(tree.Head);
            Console.WriteLine();
            Console.Write("中序遍历：");
            tree.InTraversal(tree.Head);
            Console.WriteLine();
            Console.Write("后序遍历：");
            tree.LastTraversal(tree.Head);
            Console.WriteLine();
            Console.Write("层次遍历：");
            tree.LevelTranversal(tree.Head);
            Console.WriteLine();
            Console.ReadKey();
        }
    }
}

实验结果截图：


这里写图片描述

         以上就是二叉树的顺序存储和链式存储方式，顺序存储按照数组来保存，链式按照双向链表的思想进行存储。在链式存储过程中，叶子结点会存在大量的空指针域的情况，因此引出了后续的线索二叉树，具体可以参考我写的 C#算法系列（2）——线索二叉树。本文若是有不对的或是有疑问的，欢迎留言或私信我，收到后会及时回复！

C# 二叉树
问道生的博客
11-15 1697
using System; using System.Collections; namespace helloWorld { // 二叉树的实现 public class Tree&lt;T&gt; { private TreeNode&lt;T&gt; head; public TreeNode&lt;T&gt; Head { ...
数据结构与算法——二叉树（1）
qq_50233116的博客
10-27 1662
介绍二叉树的优点、遍历二叉树、二叉树中查找数据、二叉树删除结点等
C# 数据结构 之 二叉树
weixin_30263073的博客
08-28 298
二叉树的定义 二叉树(Binary Tree)是n(n>=0)个有限元素的集合，该集合或者为空，或者由一个称为根(root)的元素及两个不相交的，被称为左子树和右子树的二叉树组成。当集合为空时，称该二叉树为空二叉树，在二叉树中，一个元素也称为一个结点。 二叉树是有序的，即若将其左右子树颠倒，就称为另一颗不同的二叉树。 二叉树的相关术语 结点的度：结点所拥有的子树的个数称为该结点的度。...
二叉树 简介与算法题
最新发布
红血哥
06-18 397
本文系统梳理了二叉树的核心概念、分类及应用。主要内容包括：1）基础概念与结构特性二叉树（满二叉树、完全二叉树、完美二叉树）；2）功能特性二叉树（二叉搜索树、AVL树、红黑树、堆）；3）特殊二叉树（字典树、哈夫曼树、B树/B+树）；4）遍历算法与时间复杂度对比；5）典型应用场景如数据库索引、数据压缩、优先队列等。通过代码示例展示了树的高度计算实现，完整覆盖了二叉树的理论知识与实际应用。
C#写算法之二叉树
知识无止境
01-19 8916
在数据结构中，树的定义如下： 树(tree)是n(n>=0)个节点的有限集，当n=0时，称为空树。在任意一个非空树中，有如下特点： 1.有且仅有一个特定的称为根的节点。 2.当n>1时，其余节点可分为m(m>0)个互不相交的有限集，每一个集合本身又是一个树，并称为根的子树。 树有以下概念： 根节点、父节点、兄弟节点、孩子节点。 树的最大层级数，被称为树的高度或深度。 ...
c# 二叉树
alice_art的专栏
09-28 1129
 本程序中将用到一棵已知的二叉树如图（二叉树图）所示。先序遍历：1.       访问根结点2.       按先序遍历左子树;3.       按先序遍历右子树；4.       例如：遍历已知二叉树结果为：A->B->D->G->H->C->E->F中序遍历：1.       按中序遍历左子树;2.       访问根结点；3.       按中序遍历右子树
c# 数据结构——二叉树——bool运算
08-02
鉴于逻辑表达式中只存在“|”（二元）、“&” （二元）和“~” （一元）三种逻辑运算符，可以采用二叉树的结构存储逻辑表达式，方便表达式的计算。 使用基于栈的逻辑表达式解析和树结构生成方法。 依次读取表达式并...
【数据结构】——二叉树的遍历算法
qq_41932198的博客
06-08 1882
题目要求 编写程序，用先序递归遍历法（或输入先序及中序递归遍历结点访问序列）建立二叉树的二叉链表存储结构，计算并输出二叉树的结点总数以及树的高度；然后输出其先序、中序、后序以及层次遍历结点访问次序。其中层次遍历的实现需使用循环队列。二叉树结点数据类型建议选用字符类型。 数据结构设计 采用C++的模板类，创建队列。每个队列对象中，elem指针用来建立长度为n的数组，n表示队列的容量，front表示队头指针，rear表示队尾指针，c表示队列中当前元素的个数。 采用结构体建立二叉树，其中，data表示数据
C#数据结构练习——平衡二叉树
Keep_Rise的博客
11-11 353
记录数据结构的练习 强调：线程不安全 本文在学习之初，有参考其他博客内容，链接如下： https://www.cnblogs.com/hongwei8455/p/3658574.html 经过自己的理解，重构优化后： <hr style=" border:solid; width:100px; height:1px;" color=#000000 size=1"> ### 直接上代码 ```csharp using System; using System.Collections.
数据结构实验——二叉树
The_star_is_at的博客
04-30 1218
// // main.cpp // 160929 // // Created by 刘哲 on 17/4/28. // Copyright © 2016年 my_code. All rights reserved. //#include #include #include #include #include #include #include #include #incl
二叉树 各种遍历算法 C#实现
07-22
二叉树 各种遍历算法 C#实现
用C#实现的二叉树（窗体应用程序）
04-21
一个用C#写的简单的二叉树，可以创建、前序遍历、中序遍历、后续遍历。Windows 窗体应用程序。
二叉树的建立和遍历（c#）
01-04
（1）能够输入二叉树的各个结点，建立二叉树； （2）按层序、先序、中序、后序遍历序列输出二叉树（要求至少其中一个遍历方法用非递归实现）。
编程学C#（3）：动态模拟创建二叉树程序
05-15
编制的动态模拟创建二叉树VS2010C#程序,按格式输入一串字符串，以@作为结束符，进行二叉树；实现二叉树的图形显示。
C#实现二叉树
aejt95023的博客
05-18 179
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using System.Threading.Tasks; 6 7 namespace BinaryTree 8 { 9 class...
数据结构之二叉树（C#版）
jmelzc的博客
01-06 2101
数据结构之二叉树（C#版）简介代码实现总结 简介 代码实现 总结
C# 二叉树的实现
中辽普坦的专栏
08-20 891
二叉树的创建： namespace BinaryTree { /// /// 二叉树的存储结构类 /// /// public class Node { public T Data { get; set; } //数据域（结点数据） public Node LeftChild { get; set; }
C#二叉树
03-27
<think>嗯，用户想了解如何用C#实现二叉树的数据结构，并提供示例代码。首先，我需要回顾一下二叉树的基本概念和C#中的实现方式。根据引用中的信息，二叉树通常由节点组成，每个节点包含数据以及左右子节点的引用。 首先，用户可能需要一个TreeNode类来定义节点结构。引用[2]和[3]提到C#中的TreeNode类通常包含Value、Left和Right属性。例如，引用[2]中的示例代码展示了TreeNode的简单定义，包含构造函数初始化值。所以，我应该先定义一个TreeNode类，包含Value和左右子节点。 接下来，用户可能需要如何构建二叉树。比如手动创建节点并连接它们。例如，创建根节点，然后为其左子节点和右子节点赋值。引用[3]提到二叉树的遍历方法，可能在构建后需要实现遍历算法，如前序、中序和后序遍历。 然后，关于遍历的实现，引用[4]讨论了非递归的前序和中序遍历，但用户可能更倾向于递归方法，因为引用[1]中的示例使用了递归的先序遍历。所以，在示例代码中应该包括递归遍历的方法，比如先序、中序和后序。 用户还可能关心如何测试这个二叉树结构。因此，示例代码应该包括Main函数中的创建节点和调用遍历方法的步骤。 需要检查是否有遗漏的部分，比如是否应该添加层次遍历或其他方法，但根据引用中的信息，用户主要询问示例代码，可能基础实现即可。同时，注意引用中提到的C#语法，比如类的定义和构造函数的使用，确保代码正确无误。 最后，生成相关问题时要围绕二叉树的实现、遍历方法、应用场景和优化等方面，帮助用户进一步学习。例如，如何实现非递归遍历，或者二叉树的应用场景有哪些，这可以引用已有的资料部分。</think>### C# 实现二叉树数据结构示例代码 #### 1. 定义二叉树节点类 ```csharp public class TreeNode { public int Value; // 节点存储的值 public TreeNode Left; // 左子节点 public TreeNode Right; // 右子节点 public TreeNode(int value) { Value = value; Left = null; Right = null; } } ``` 这是二叉树的核心结构定义，每个节点包含值、左子树和右子树指针[^2][^3]。 #### 2. 构建二叉树 ```csharp // 手动构建一个简单的二叉树 TreeNode root = new TreeNode(1); root.Left = new TreeNode(2); root.Right = new TreeNode(3); root.Left.Left = new TreeNode(4); root.Left.Right = new TreeNode(5); ``` 该示例构建了一个如下结构的二叉树： ``` 1 / \ 2 3 / \ 4 5 ``` #### 3. 实现遍历算法 **前序遍历（根-左-右）**： ```csharp public static void PreOrderTraversal(TreeNode node) { if (node == null) return; Console.Write(node.Value + " "); PreOrderTraversal(node.Left); PreOrderTraversal(node.Right); } ``` **中序遍历（左-根-右）**： ```csharp public static void InOrderTraversal(TreeNode node) { if (node == null) return; InOrderTraversal(node.Left); Console.Write(node.Value + " "); InOrderTraversal(node.Right); } ``` **后序遍历（左-右-根）**： ```csharp public static void PostOrderTraversal(TreeNode node) { if (node == null) return; PostOrderTraversal(node.Left); PostOrderTraversal(node.Right); Console.Write(node.Value + " "); } ``` #### 4. 测试代码 ```csharp static void Main(string[] args) { // 构建示例二叉树 TreeNode root = new TreeNode(1); root.Left = new TreeNode(2); root.Right = new TreeNode(3); root.Left.Left = new TreeNode(4); root.Left.Right = new TreeNode(5); Console.Write("前序遍历: "); PreOrderTraversal(root); // 输出：1 2 4 5 3 Console.Write("\n中序遍历: "); InOrderTraversal(root); // 输出：4 2 5 1 3 Console.Write("\n后序遍历: "); PostOrderTraversal(root); // 输出：4 5 2 3 1 } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值