C#写算法之二叉树

在数据结构中，树的定义如下：

树(tree)是n(n>=0)个节点的有限集，当n=0时，称为空树。在任意一个非空树中，有如下特点：

1.有且仅有一个特定的称为根的节点。

2.当n>1时，其余节点可分为m(m>0)个互不相交的有限集，每一个集合本身又是一个树，并称为根的子树。

树有以下概念：

根节点、父节点、兄弟节点、孩子节点。

树的最大层级数，被称为树的高度或深度。

二叉树：

二叉树(binary tree)是树的一种特殊形式。二叉，指的是这种树的每个节点最多有2个孩子节点。这里最多有2个，也可能只有1个，或者没有孩子节点。

二叉树的两个特殊概念：满二叉树和完全二叉树。

满二叉树：（每一个分支都是满的），所有非叶子节点都存在左右孩子，并且所有叶子节点都在同一层级上。

完全二叉树：对于一个有n个节点的二叉树，按层级顺序编号，则所有节点的编号为从1到n。如果这个树所有节点和同样深度的满二叉树的编号为从1到n的节点位置相同。则这个二叉树为完全二叉树。

二叉树可以用链式存储和数组两种物理存储结构来表达。

链式存储：

二叉树的一个节点最多指向左右两个孩子节点，所以二叉树一个节点包含3部分;

1.存储数据的data变量

2.指向左孩子的left指针

3.指向右孩子的right指针

使用数组存储：

使用数组存储时，会按照层级顺序把二叉树的节点放到数组中对应的位置上。如果某一个节点的左孩子和右孩子空缺，则数组的相应位置也空出来。

这样设计，可以更方便地在数组中定位二叉树的孩子节点和父节点。

假设一个父节点的下标是parent，那么它的左孩子节点下标就是2*parent+1；右孩子节点下标是2*parent+2。

反过来，一个左孩子的节点下标是leftChild，那么父节点下标就是(leftChild-1)/2。

二叉树的应用：

最主要的应用在于进行查找操作和维持相对顺序两个方面。

1.查找：二叉查找树(binary search tree)

二叉查找树在二叉树的基础上增加了以下几个条件：

1、若左子树不为空，则左子树所有节点的值均小于根节点的值；

2、若右子树不为空，则右子树所有节点的值均大于根节点的值；

3、左、右子树也都是二叉查找树。

对于一个节点分布相对均衡的二叉查找树，如果左节点总数是n，那么搜索节点的时间复杂度就是O(logn)，和树的深度是一样的。

这种依靠比较大小来逐步查找的方式，和二分查找算法非常相似。

2.维持相对顺序

二叉查找树要求左子树小于父节点，右子树大于父节点，这样保证了二叉树的有序性，因此 二叉查找树也叫二叉排序树。

新插入的节点，遵循二叉排序树的原则：例如插入新元素5，由于5<6，5>3,5>4，所以5最终会插入到节点4的右孩子位置。

再如插入新元素10，由于10>6，10>8，10>9，所以10最终会插入到节点9的右孩子位置。

问题：如果依次插入9、8、7、6、5、4，就会让查询节点的时间复杂度退化成O(n)。

解决：二叉树的自平衡，如红黑树、ALV树、树堆等。

二叉堆：只要求父节点比它的左右孩子都大。

二叉树的遍历

从节点之间位置关系的角度看，二叉树的遍历可分为4种：

1.前序遍历：根节点、左子树、右子树。

2.中序遍历：左子树、根节点、右子树

3.后序遍历：左子树、右子树、根节点

4.层序遍历：一层一层遍历

从更宏观的角度看，二叉树的遍历归结为两大类。

1.深度优先遍历（前序遍历、中序遍历、后序遍历）。偏向于纵深，一头扎下去。

2.广度优先遍历（层序遍历）

前、中、后：

using System;
using System.Collections.Generic;

namespace CSharpTest01
{
    public static class LinkedListExtension
    {
        public static int RemoveFirstEx(this LinkedList<int> list)
        {
            //int value = Convert.ToInt32(list.First);
            int value = list.First.Value;
            list.RemoveFirst();
            return value;
        }
    }
    public class TreeNode
    {
        public int data;
        public TreeNode leftChild;
        public TreeNode rightChild;

        public TreeNode(int data)
        {
            this.data = data;
        }
    }

    public class MyBinaryTree
    {
        /// <summary>
        /// 创建一颗完整二叉树
        /// </summary>
        public TreeNode CreateBinaryTree2(LinkedList<int> inputList, int index, int len)
        {
            TreeNode node = null;
            if (inputList == null || inputList.Count <= 0)
            {
                return null;
            }
            if(index<len)
            {
                node = new TreeNode(array[index]};
                node.leftChild = CreateBinaryTree2(inputList, 2*index+1, len)
                node.rightChild = CreateBinaryTree2(inputList, 2*index+2, len)
            }
            return node;
        }
        
        /// <summary>
        /// 创建二叉树
        /// </summary>
        public TreeNode CreateBinaryTree(LinkedList<int> inputList)
        {
            TreeNode node = null;
            if (inputList == null || inputList.Count <= 0)
            {
                return null;
            }
            int data = inputList.RemoveFirstEx();
            if (data != null)
            {
                node = new TreeNode(data);
                node.leftChild = CreateBinaryTree(inputList);
                node.rightChild = CreateBinaryTree(inputList);
            }
            return node;
        }
        /// <summary>
        /// 二叉树前序遍历
        /// </summary>
        public void PreOrderTraveral(TreeNode node)
        {
            if (node == null)
            {
                return;
            }
            Console.WriteLine(node.data);
            PreOrderTraveral(node.leftChild);
            PreOrderTraveral(node.rightChild);
        }
        /// <summary>
        /// 中序遍历
        /// </summary>
        public void InOrderTraveral(TreeNode node)
        {
            if (node == null)
            {
                return;
            }
            InOrderTraveral(node.leftChild);
            Console.WriteLine(node.data);
            InOrderTraveral(node.rightChild);
        }
        /// <summary>
        /// 后序遍历
        /// </summary>
        public void PostOrderTraveral(TreeNode node)
        {
            if (node == null)
            {
                return;
            }
            PostOrderTraveral(node.leftChild);
            PostOrderTraveral(node.rightChild);
            Console.WriteLine(node.data);
        }
        /// <summary>
        /// 二叉树非递归前序遍历
        /// </summary>
        public void PreOrderTraveralWithStack(TreeNode root)
        {
            Stack<TreeNode> stack = new Stack<TreeNode>();
            TreeNode treeNode = root;
            while (treeNode != null || stack.Count > 0)
            {
                // 迭代访问节点的左孩子，并入栈
                while (treeNode != null)
                {
                    Console.WriteLine(treeNode.data);
                    stack.Push(treeNode);
                    treeNode = treeNode.leftChild;
                }
                // 如果节点没有左孩子，则弹出栈顶节点，访问节点右孩子
                if (stack.Count > 0)
                {
                    treeNode = stack.Pop();
                    treeNode = treeNode.rightChild;
                }
            }
        }
        public void LevelOrderTraversal(TreeNode root)
        {
            Queue<TreeNode> queue = new Queue<TreeNode>();
            queue.Enqueue(root);
            while (queue.Count > 0)
            {
                TreeNode node = queue.Dequeue();
                Console.WriteLine(node.data);
                if (node.leftChild != null)
                {
                    queue.Enqueue(node.leftChild);
                }
                if (node.rightChild != null)
                {
                    queue.Enqueue(node.rightChild);
                }
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            int[] nums = new int[11];
            nums[0] = 3;
            nums[1] = 2;
            nums[2] = 9;
            nums[5] = 10;
            nums[8] = 8;
            nums[10] = 4;
            LinkedList<int> inputList = new LinkedList<int>(nums);
            MyBinaryTree myBinaryTree = new MyBinaryTree();
            TreeNode treeNode = myBinaryTree.CreateBinaryTree(inputList);
            Console.WriteLine("前序遍历：");
            myBinaryTree.PostOrderTraveral(treeNode);
            //Console.WriteLine("中序遍历：");
            //myBinaryTree.InOrderTraveral(treeNode);
            //Console.WriteLine("后序遍历：");
            //myBinaryTree.PostOrderTraveral(treeNode);
            Console.WriteLine("非递归前序遍历：");
            myBinaryTree.PreOrderTraveralWithStack(treeNode);
            Console.ReadLine();
        }
    }
}

用递归实现前、中、后序是最自然的方式，3种遍历方式的区别仅仅是输出的执行位置不同：前序遍历的输出在前，中序遍历的输出在中间，后序遍历的输出在最后。

二叉树的构建方式很多，这里把一个线性的链表转化成非线性的二叉树。

拓展：

可以用递归解决的方法，同样可以用栈解决，递归和栈都有回溯的特性。