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

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

一、 二叉树的性质

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

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）——线索二叉树。本文若是有不对的或是有疑问的，欢迎留言或私信我，收到后会及时回复！