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

来源：互联网发布：艾滋病歧视知乎日报编辑：程序博客网时间：2024/06/05 02:45

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

一、二叉树的性质

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

在二叉树的第i层上至多有2^(i-1)个结点（i≥1）。
深度为k的二叉树至多有2^k -1 个结点(k≥1)。
对任何一棵二叉树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.
具有n个结点的完全二叉树的深度为log2 (n) + 1。
如果对一棵有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）——线索二叉树。本文若是有不对的或是有疑问的，欢迎留言或私信我，收到后会及时回复！

阅读全文

0 0

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

一、 二叉树的性质

二、二叉树的构建

三、二叉树的具体实现

一、二叉树的性质