二叉树 深度遍历

定义 每个结点至多有两颗子树（即二叉树不存在度大于2的结点），并且二叉树的子树有左右之分，其次序不能任意颠倒，即如果将其左右字数颠倒，就成为另一颗不同的二叉树。

二叉树的储存结构

1.顺序存储结构

2.链式存储结构

什么是顺序存储结构？实际上跟数组差不多

根据数组画出二叉树

看到规律没？

左节点+1  ，右节点+2

3的左节点=2x3+1=7这表示数组的下标，

3的右节点=2x3+2=8 .........

2.链式存储结构

┌───┬——─┬—──┐
│L     │data │ R    │
└───┴──--┴——─┘

  public  class BinaryTreeNode
    {
        private object _data;//数据
        private BinaryTreeNode _left;//左孩子
        private BinaryTreeNode _right;//右孩子

        public object Data
        {
            get {return _data ;}
        }

        public BinaryTreeNode Left
        {
            get { return _left;}
            set { _left=value;}
        }
        public BinaryTreeNode Right
        {
            get { return _right; }
            set { _right = value; }
        }

        public BinaryTreeNode(object data)
        {
            _data = data;
        }

        public override string ToString()
        {
            return _data.ToString();
        }
    }

  class BinaryTree
    {
        private BinaryTreeNode _head;//头指针
        private string cStr;//用于构造二叉树的字符串

        public BinaryTreeNode Head//头指针
        {
            get {return _head ;}
        }

        public BinaryTree(string str)
        {
            cStr = str;
            _head = new BinaryTreeNode(cStr[0]);//添加头结点
            ADD(_head,0);//增加孩子结点
        }


        private void ADD(BinaryTreeNode parent,int index)
        {//index 双亲结点的下标

            int leftIndex = 2 * index + 1;//左孩子的下标  
            if (leftIndex<cStr.Length)//存在左孩子
            {
                if (cStr[leftIndex] != \'#\')//左孩子不是空结点
                {//添加左孩子
                    parent.Left = new BinaryTreeNode(cStr[leftIndex]);

                    //递归方法添加左孩子的左孩子和右孩子
                    ADD(parent.Left,leftIndex);
                }
            }

            int rightIndex = 2 * index + 2;//右孩子的下标
            if (rightIndex<cStr.Length)
            {
                if (cStr[rightIndex]!=\'#\')
                {
                    parent.Right = new BinaryTreeNode(cStr[rightIndex]);
                    ADD(parent.Right, rightIndex);
                }
            }
        }

        public void PreOrder(BinaryTreeNode node)//先序遍历
        {
            if (node!=null)//此二叉树不为空树
            {
                Console.WriteLine(node);
                PreOrder(node.Left);
                PreOrder(node.Right);
            }
        }

        public void MidOrder(BinaryTreeNode node) //中序遍历
        {
            if (node!=null)
            {
                MidOrder(node.Left);
                Console.WriteLine(node);
                MidOrder(node.Right);
            }
        }

        public void AfterOrder(BinaryTreeNode node) //后序遍历
        {
            if (node != null)
            {
                AfterOrder(node.Left);
                AfterOrder(node.Right);
                Console.WriteLine(node);
            }
        }
    }

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

namespace ConsoleApplication13
{
    class Program
    {
        static void Main(string[] args)
        {
            BinaryTree tree = new BinaryTree("ABCDE#F");
            Console.WriteLine("ABCDE#F 先序遍历的结果为：");

            tree.PreOrder(tree.Head);//先序遍历输出

            Console.WriteLine("ABCDE#F 中序遍历的结果为：");
            tree.MidOrder(tree.Head);

            Console.WriteLine("ABCDE#F 后序遍历的结果为：");
            tree.AfterOrder(tree.Head);

            Console.ReadLine();
        }
    }
}