二叉树遍历

二叉树遍历四种：前序遍历、中序遍历、后续遍历、层序遍历

前序遍历：线输出当前数据，然后输出左结点， 当左结点输出完成，再输出右结点

解析：先输出当前结点  A  然后输出左结点  B   

所以当前  A B   但此时B仍有左结点，并未输出完成

输出当前结点B，之后输出他的左结点 D

所以当前ABD    但此时D仍有左子结点，并未输出完成，可理解为B也未完成

输出当前结点D，之后输出他的左结点 G，此时D的左结点完全输出完成，可输出他的右结点H

所以当前ABDGH   H输出完成后，整个D输出完成，即B的左结点完全输出完成，无右结点，所以B整个输出完成，即A的左结点完全输出完成，  接下来输出A的右结点C

所以当前ABDGHC  

C之后输出左结点E  但E仍有结点，无左，输出右

ABDGHCEI    此时C的左结点完全输出完成，输出他的右结点F

最终ABDGHCEIF

C#代码如下

private void FirstTraversal(int index)
        {
            if (index >= count) return;
            //得到要遍历的这个结点的编号 
            int number = index + 1;
            if (data[index].Equals(-1)) return;

            Console.Write(data[index]+" ");//-----------先输出当前数据

            //得到左子结点的编号
            int leftNumber = number * 2;
            int rightNumber = number * 2 + 1;
            FirstTraversal(leftNumber - 1);//----------在输出左结点
            FirstTraversal(rightNumber - 1);// ----------最后输出右结点
        }

中序遍历：先遍历完成当前数据的左结点，在遍历当前数据，最后遍历右结点

要输出当前数据A， 但要先输出其左结点B

此时预排序BA    但要输出B，要先输出其左结点D

此时预排序DBA   但要输出D，要先输出其左结点G

此时预排序GDBA    G没有左结点可以真正输出，然后真正输出D，在输出其右结点H

则真排序GDH   B的左结点完全输出，B可输出，但无右结点了

则真排序GDHB  A的左结点完全输出完成，A可以输出，无左结点，要输出右结点C，但是C输出之前要求其左结点E输出完成，E无左结点，可以输出,并输出右结点I，I无左结点，可真正输出

则真排序GDHBEI   此时C的左结点完全输出，C可以输出了，之后输出右结点F，F无左结点，可以真正输出

最后GDHBEICF

C#代码

public void MiddleTraversal()
        {
            MiddleTraversal(0);
        }
        private void MiddleTraversal(int index)
        {
            if (index >= count) return;
            //得到要遍历的这个结点的编号 
            int number = index + 1;
            if (data[index].Equals(-1)) return;
            //得到左子结点的编号
            int leftNumber = number * 2;
            int rightNumber = number * 2 + 1;
            MiddleTraversal(leftNumber - 1);//----------先输出左结点
            Console.Write(data[index] + " ");//---------在输出当前数据
            MiddleTraversal(rightNumber - 1);//----------最后输出右结点
        }

 后序遍历：先遍历完成左结点，在遍历完成右结点，最后输出当前数据

输出当前数据A   前要先依次输出B C

预排序BCA

先看B  输出B之前要先输出 D，D输出之前，要先输出G H   G无左右结点可直接输出，然后输出H，此时G可以输出了

真排序GHD       所以GHDB  到此，A的左结点完全输出完成，，在看C

C输出前要输出E F  

预排序EFC

E输出之前要先输出I  I可直接输出  此时可输出E了，E之后输出F，F无子结点，可直接输出，此时C的左右结点都输出完成，可以输出C了

C的真排序IEFC

连接之后GHDB EFC   此时A的左右结点完全输出完成，A可以输出

最后GHDBIEFCA

C#代码

 public void LastTraversal()
        {
            LastTraversal(0);
        }
        private void LastTraversal(int index)
        {
            if (index >= count) return;
            //得到要遍历的这个结点的编号 
            int number = index + 1;
            if (data[index].Equals(-1)) return;
            //得到左子结点的编号
            int leftNumber = number * 2;
            int rightNumber = number * 2 + 1;
            LastTraversal(leftNumber - 1);//---------先输出左结点
            LastTraversal(rightNumber - 1);//---------在输出右结点
            Console.Write(data[index] + " ");//--------最后输出当前数据
        }

完全代码：

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

namespace 二叉树___顺序结构存储
{
    //如果一个结点是空的话，那么这个结点所在的数组位置，设置为-1，
    class BiTree<T>
    {

        private T[] data;
        private int count = 0;
        public BiTree(int capacity)// 这个参数是当前二叉树的容量，容量就是最多可以存储的数据个数， 数量count代表当前保存了多少个数据
        {
            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) return;
            //得到要遍历的这个结点的编号 
            int number = index + 1;
            if (data[index].Equals(-1)) return;

            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) return;
            //得到要遍历的这个结点的编号 
            int number = index + 1;
            if (data[index].Equals(-1)) return;
            //得到左子结点的编号
            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) return;
            //得到要遍历的这个结点的编号 
            int number = index + 1;
            if (data[index].Equals(-1)) return;
            //得到左子结点的编号
            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] + " ");
            }
            Console.WriteLine();
        }
    }
}

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' };//这个是我们要存储的数据
            BiTree<char> tree = new BiTree<char>(10);
            for (int i = 0; i < data.Length; i++)
            {
                tree.Add(data[i]);
            }
            tree.FirstTraversal();//先序
            Console.WriteLine();
            tree.MiddleTraversal();//中序
            Console.WriteLine();
            tree.LastTraversal();//后序
            Console.WriteLine();
            tree.LayerTraversal();//层序
            Console.ReadKey();
        }
    }
}

输出结果