C# 创建二叉树以及深度遍历二叉树

之前项目用到了树形存储的配置结构，多叉树除了用于配置结构外，还有用于复杂文件目录结构。
二叉树一个比较经典的应用是红黑树，查找、插入、删除的时间复杂度最坏为O(log n)，效率高。
很多语言的hashmap用红黑树来做。

二叉树的基础操作学会了，多叉树的基础操作也就学会了。

---

原文： C#代码创建二叉树以及遍历二叉树

二叉树的前中后序遍历，是根据遍历时根节点在其左右子树中的相对顺序定义的。
对于每一个节点来说，前序是只先遍历根节点，然后左子树，然后右子树
中序是先左子树，然后根节点，然后右子树
后序是先左子树，然后右子树，然后根节点
以下图所属树来做例子。

节点定义

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

namespace BinaryDemo
{
    public class TreeNode
    {
        /*
         * 树的知识点
         * 树结点 根结点 结点子树
         * 结点的度  结点关系 结点层次
         * 树的深度/高度
         */
        //结点下标  结点下标字符串数据 左子树 右子树
        private int index;
        private string data;
        private TreeNode leftChild;
        private TreeNode rightChild;
        private TreeNode parent;


        /// 

        /// 有参构造结点下标  结点下标的字符串数据
        /// 
        /// 
        /// 
        public TreeNode(int index, string data)
        {
            this.index = index;
            this.data = data;
            this.leftChild = null;
            this.rightChild = null;
        }

        public int getIndex()
        {
            return index;
        }
        public void setIndex(int index)
        {
            this.index = index;
        }
        //拿到左右子串的数据
        public String getData()
        {
            return data;
        }
        public void setData(String data)
        {
            this.data = data;
        }
        //拿到左子树
        public TreeNode getLeftChild()
        {
            return leftChild;
        }
        public void setLeftChild(TreeNode leftChild)
        {
            this.leftChild = leftChild;
        }
        //拿到右子树
        public TreeNode getRightChild()
        {
            return rightChild;
        }
        public void setRightChild(TreeNode rightChild)
        {
            this.rightChild = rightChild;
        }
        public TreeNode getParent()
        {
            return parent;
        }
        public void setParent(TreeNode parent)
        {
            this.parent = parent;
        }
        //快捷键生成的字段get和set
        public int Index { get => index; set => index = value; }
        public string Data { get => data; set => data = value; }
        public TreeNode LeftChild { get => leftChild; set => leftChild = value; }
        public TreeNode RightChild { get => rightChild; set => rightChild = value; }
        public TreeNode Parent { get => parent; set => parent = value; }
    }
}

创建二叉树

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

namespace BinaryDemo
{
    public class BinaryTree
    {
        //根结点
        public TreeNode root = null;
        public static string[] str;
        public static int count;
        /// 

        /// 无参构造设置根结点并赋值数据
        /// 
        public BinaryTree()
        {
            root = new TreeNode(1,"A");
        }
        /// 

        /// 构建二叉树的方法    B C D E F
        /// 手动的构建一棵二叉树  很快就可以得出这个二叉树的结构
        /// 
        public void CreateBinaryTree()
        {
            TreeNode nodeb = new TreeNode(2,"B");
            TreeNode nodec = new TreeNode(3, "C");
            TreeNode noded = new TreeNode(4, "D");
            TreeNode nodee = new TreeNode(5, "E");
            TreeNode nodef = new TreeNode(6, "F");
            root.LeftChild = nodeb;
            root.RightChild = nodec;
            nodeb.LeftChild = noded;
            nodeb.RightChild = nodee;
            nodec.RightChild = nodef;
        }

递归遍历

前序遍历

		/// 

        /// 先序遍历 --迭代
        /// 若二叉树为空树直接返回，先序遍历的特点根左右
        /// 
        public void PreOrder(TreeNode node)
        {
            if (node == null)
            {
                return;
            }
            else
            {
                //node.getData()我们可以获取到二叉树的根结点的数据
                Console.WriteLine("先序遍历" + "\t迭代" + node.getData());
                //得到左子树的数据
                PreOrder(node.LeftChild);
                //得到右子树的数据
                PreOrder(node.RightChild);
            }
        }

1. 打印结点A，此时属于第零层递归，结点A左子树进入第一层递归

2. 第一层递归中，打印结点A左子树的根结点B，结点B左子树进入第二层递归

3. 第二层递归中，打印结点B左子树的根结点D，结点D左子树进入第三层递归

4. 第三层递归中，因为结点D左子树为空，返回第二层递归，返回后，代码运行到了访问结点D右子树部分，结点D右子树进入第三层递归

5. 因为结点D右子树为空，返回第二层递归，第二层访问的是结点D，返回后已经进入第二层函数尽头，第二层递归结束，返回第一层递归，第一层递归访问的是结点B

6. 返回到第一层递归中，代码到了结点B右子树的部分，结点B右子树进入第二层递归

7. 第二层递归中，打印结点B右子树的根结点E，然后结点E左子树进入第三层递归

8. 第三层递归中，结点E左子树为空，返回第二层递归，返回时第二层递归的代码到了访问结点E右子树部分，进入第三层递归

9. 进入第三层递归中，结点E右子树为空，返回第二层递归。

10. 返回到第二层的时候函数已经进入结束部分，再次返回第一层递归，返回到第一层的时候，第一层递归已经遍历完B右子树，函数进入结束部分，返回第零层递归，第零层递归访问的是结点A。

11. 返回到第零层递归后，代码进入到访问A的右子树部分，结点A右子树进入第一层递归

12. 第一层递归中， 打印结点A右子树的根结点C，结点C左子树进入第二层递归

13. 第二层递归中，结点C左子树为空，返回第一层递归，返回后，代码到了访问第一层递归的C的右子树部分，结点C右子树进入第二层递归

14. 第二层递归中， 打印结点C右子树的根结点F，结点F左子树进入第三层递归

15. 第三层递归中，结点F左子树为空，返回第二层递归

16. 返回到第二层递归的时候，代码到了访问第二层递归的F的右子树部分，结点F右子树进入第三层递归

17. 第三层递归中，结点F右子树为空，返回第二层递归

18. 返回到第二层，第二层访问的是结点F，此时结点F左右子树都已经访问完毕，第二层递归函数已经进入函数结尾，第二层递归结束，返回第一层递归。

19. 返回到第一层，第一层访问的是结点C，此时遍历完C右子树，第一层递归函数进入结束部分，返回第零层递归。

20. 返回到第零层，第零层递归访问的是结点A，此时遍历完A右子树，第零层递归函数进入结束部分，所有遍历结束。

这些流程下来，打印的顺序依次为ABDECF，符合前序遍历的要求。

中序遍历

		/// 

        /// 中序遍历--递归
        /// 若二叉树为空树直接返回，中序遍历的特点左根右
        /// 
        /// 
        public void MidOrder(TreeNode node)
        {
            if (node == null)
            {
                return;
            }
            else
            {
                MidOrder(node.LeftChild);
                Console.WriteLine("中序遍历" + "\t迭代" + node.getData());
                MidOrder(node.RightChild);
            }
        }

1. 第零层递归，访问的是结点A，结点A左子树进入第一层递归

2. 第一层递归中，访问的是结点A左子树的根节点是结点B，结点B左子树进入第二层递归

3. 第二层递归中，访问的是结点B左子树的根节点是结点D，结点D左子树进入第三层递归

4. 第三层递归中，因为结点D左子树为空，返回第二层递归。

5. 返回第二层递归后，代码进入打印当前层结点部分，打印第二层访问的结点D，然后代码运行到了访问结点D右子树部分，结点D右子树进入第三层递归。

6. 第三层递归中，因为结点D右子树为空，返回第二层递归。

7. 第二层访问的是结点D，返回后已经进入第二层函数尽头，第二层递归结束，返回第一层递归，第一层递归访问的是结点B

8. 返回到第一层递归中，代码到了打印当前访问结点的部分，当前访问结点是B，打印结点B，然后结点B右子树进入第二层递归

9. 第二层递归中，访问的是结点B右子树的根结点E，然后结点E左子树进入第三层递归

10. 第三层递归中，结点E左子树为空，返回第二层递归，返回时第二层递归的代码到了打印当前访问结点的部分，当前访问结点是E，打印结点E，然后访问结点E右子树部分，进入第三层递归

11. 进入第三层递归中，结点E右子树为空，返回第二层递归。

12. 返回到第二层的时候函数已经进入结束部分，再次返回第一层递归，返回到第一层的时候，第一层递归已经遍历完B右子树，函数进入结束部分，返回第零层递归，第零层递归访问的是结点A。

13. 返回到第零层递归后，代码到了打印当前访问结点的部分，当前访问结点是A，打印结点A，然后代码进入到访问A的右子树部分，结点A右子树进入第一层递归

14. 第一层递归中， 访问的是结点A右子树的根节点结点C，结点C左子树进入第二层递归

15. 第二层递归中，结点C左子树为空，返回第一层递归，返回后，代码到了打印当前访问结点的部分，当前访问结点是C，打印结点C。

16. 访问第一层递归的C的右子树部分，结点C右子树进入第二层递归

17. 第二层递归中， 访问的是结点C右子树的根结点F，结点F左子树进入第三层递归

18. 第三层递归中，结点F左子树为空，返回第二层递归

19. 返回到第二层递归的时候，代码到了打印当前访问结点的部分，当前访问结点是F，打印结点F，然后代码到了访问第二层递归的F的右子树部分，结点F右子树进入第三层递归

20. 第三层递归中，结点F右子树为空，返回第二层递归

21. 返回到第二层，第二层访问的是结点F， 此时结点F左右子树都已经访问完毕，第二层递归函数已经进入函数结尾，第二层递归结束，返回第一层递归。

22. 返回到第一层，第一层访问的是结点C，此时遍历完C右子树，第一层递归函数进入结束部分，返回第零层递归。

23. 返回到第零层，第零层递归访问的是结点A，此时遍历完A右子树，第零层递归函数进入结束部分，所有遍历结束。

这些流程下来，打印的顺序依次为DBEACF，符合中序遍历的要求。

后序遍历

		public void LastOrder(TreeNode node)
       {
           if (node == null)
           {
               return;
           }
           else
           {
               LastOrder(node.LeftChild);
               LastOrder(node.RightChild);
               Console.WriteLine("后序遍历" + "\t迭代" + node.getData());
           }
       }

1. 第零层递归，访问的是结点A，结点A左子树进入第一层递归

2. 第一层递归中，访问的是结点A左子树的根节点是结点B，结点B左子树进入第二层递归

3. 第二层递归中，访问的是结点B左子树的根节点是结点D，结点D左子树进入第三层递归

4. 第三层递归中，因为结点D左子树为空，返回第二层递归。

5. 返回第二层递归后，第二层递归访问的是结点D，结点D右子树进入第三层递归。

6. 第三层递归中，因为结点D右子树为空，返回第二层递归。

7. 第二层访问的是结点D，返回后已经进入打印当前结点部分，打印第二层递归访问的结点D，第二层递归结束，然后第二层递归结束，返回第一层递归

8. 返回到第一层递归中，代码到了访问当前递归结点的右子树的部分，当前第一层访问结点是B， 结点B右子树进入第二层递归

9. 第二层递归中，访问的是结点B右子树的根结点E，然后结点E左子树进入第三层递归

10. 第三层递归中，结点E左子树为空，返回第二层递归。

11. 返回第二层递归时，代码到了访问当前访问结点的右子树部分，当前访问结点是E，访问结点E右子树部分，进入第三层递归

12. 进入第三层递归中，结点E右子树为空，返回第二层递归。

13. 第二层访问的是结点E，返回后结点E的左右子树都已经遍历完成，进入打印当前结点部分，当前结点部分是E，打印E，第二层递归结束，返回第一层递归。

14. 返回第一层递归时，第一层递归已经将当前结点的左右子树都遍历完毕，这时打印当前遍历结点，当前遍历的结点是B，打印B，然后当前层遍历结束，返回第零层遍历

15. 第零层遍历访问的是结点A，返回时结点A的左子树遍历结束，结点A的右子树进入第一层递归。

16. 第一层递归，访问A的右子树的根节点C，然后第二层递归访问C的左子树

17. 第二层递归中，结点E左子树为空，返回第一层递归

18. 返回第一层递归时，代码到了访问当前结点的右子树部分，结点C的右子树进入第二层递归

19. 第二层递归中，访问结点C的右子树的根节点F，然后进入第三层递归，访问F的左子树

20. 第三层递归中，F的左子树为空，返回第二层

21. 返回第二层时，代码到了访问当前结点的右子树部分，第三层递归访问F的右子树

22. 第三层递归中，F的右子树为空，返回第二层

23. 返回第二层时，代码走到了打印当前访问结点的部分，当前访问结点是F，打印F，然后第二层递归结束，返回第一层递归

24. 返回第一层时，第一层递归已经将当前结点的左右子树都遍历完毕，代码走到了打印当前访问结点的部分，当前访问结点是C，打印C，然后第一层递归结束，返回第零层递归

25. 返回第零层时，第零层递归已经将当前结点的左右子树都遍历完毕，代码走到了打印当前访问结点的部分，当前访问结点是A，打印A，然后第零层递归结束，所有递归结束

这些流程下来，打印的顺序依次为DEBFCA，符合后序遍历的要求。