c# 二叉树

本程序中将用到一棵已知的二叉树如图（二叉树图）所示。

先序遍历：

1.       访问根结点

2.       按先序遍历左子树;

3.       按先序遍历右子树；

4.       例如：遍历已知二叉树结果为：A->B->D->G->H->C->E->F

中序遍历：

1.       按中序遍历左子树;

2.       访问根结点；

3.       按中序遍历右子树；

4.       例如遍历已知二叉树的结果：B->G->D->H->A->E->C->F

后序遍历：

1.       按后序遍历左子树；

2.       按后序遍历右子树；

3.       访问根结点；

4.       例如遍历已知二叉树的结果：G->H->D->B->E->F->C->A

层次遍历：

1.       从上到下，从左到右遍历二叉树的各个结点(实现时需要借辅助容器)；

2.       例如遍历已知二叉树的结果：A->B->C->D->E->F->G->H

Code
  1using System;
  2using System.Collections.Generic;
  3using System.Text;
  4
  5namespace ConsoleApplication1
  6{
  7    class Program
  8    {
  9        
 10
 11        二叉树结点数据结构的定义#region 二叉树结点数据结构的定义 
 12        //二叉树结点数据结构包括数据域，左右结点以及父结点成员；
 13      class nodes<T>
 14        {
 15            T data;
 16            nodes<T> Lnode, Rnode, Pnode;
 17            public T Data
 18            {
 19                set { data = value; }
 20                get { return data; }
 21
 22            }
 23            public nodes<T> LNode
 24            {
 25                set { Lnode = value; }
 26                get { return Lnode; }
 27            }
 28            public nodes<T> RNode
 29            {
 30                set { Rnode = value; }
 31                get { return Rnode; }
 32
 33            }
 34
 35            public nodes<T> PNode
 36            {
 37                set { Pnode = value; }
 38                get { return Pnode; }
 39
 40            }
 41          public nodes()
 42          { }
 43          public nodes(T data)
 44          {
 45              this.data = data;
 46          }
 47
 48        } 
 49        #endregion
 50
 51        先序编历二叉树#region 先序编历二叉树
 52        static void PreOrder<T>(nodes<T> rootNode)
 53        {
 54            if (rootNode != null)
 55            {
 56                Console.WriteLine(rootNode.Data);
 57                PreOrder<T>(rootNode.LNode);
 58                PreOrder<T>(rootNode.RNode);
 59
 60            }
 61        }
 62        
 63        #endregion
 64
 65        构造一棵已知的二叉树#region 构造一棵已知的二叉树
 66
 67        static nodes<string> BinTree()
 68        {
 69            nodes<string>[] binTree = new nodes<string>[8];
 70            //创建结点
 71            binTree[0] = new nodes<string>("A");
 72            binTree[1] = new nodes<string>("B");
 73            binTree[2] = new nodes<string>("C");
 74            binTree[3] = new nodes<string>("D");
 75            binTree[4] = new nodes<string>("E");
 76            binTree[5] = new nodes<string>("F");
 77            binTree[6] = new nodes<string>("G");
 78            binTree[7] = new nodes<string>("H");
 79            //使用层次遍历二叉树的思想，构造一个已知的二叉树
 80
 81            binTree[0].LNode = binTree[1];
 82            binTree[0].RNode = binTree[2];
 83            binTree[1].RNode = binTree[3];
 84            binTree[2].LNode = binTree[4];
 85            binTree[2].RNode = binTree[5];
 86            binTree[3].LNode = binTree[6];
 87            binTree[3].RNode = binTree[7];
 88            //返回二叉树的根结点
 89            return binTree[0];
 90
 91
 92
 93        }
 94        #endregion
 95
 96        中序遍历二叉树#region 中序遍历二叉树
 97        static void MidOrder<T>(nodes<T> rootNode)
 98        {
 99            if (rootNode != null)
100            {
101                MidOrder<T>(rootNode.LNode);
102                Console.WriteLine(rootNode.Data);
103                MidOrder<T>(rootNode.RNode);
104            }
105        } 
106        #endregion
107        
108        后序遍历二叉树#region 后序遍历二叉树
109        static void AfterOrder<T>(nodes<T> rootNode)
110        {
111            if (rootNode != null)
112            {
113                AfterOrder<T>(rootNode.LNode);
114                AfterOrder<T>(rootNode.RNode);
115                Console.WriteLine(rootNode.Data);
116            }
117
118        } 
119        #endregion
120
121        层次遍历二叉树#region 层次遍历二叉树
122        static void LayerOrder<T>(nodes<T> rootNode)
123        {
124            nodes<T>[] Nodes = new nodes<T>[20];
125            int front = -1;
126            int rear = -1;
127            if (rootNode != null)
128            {
129                rear++;
130                Nodes[rear] = rootNode;
131
132            }
133
134            while (front != rear)
135            {
136                front++;
137                rootNode = Nodes[front];
138                Console.WriteLine(rootNode.Data);
139                if (rootNode.LNode != null)
140                {
141                    rear++;
142                    Nodes[rear] = rootNode.LNode;
143                }
144                if (rootNode.RNode != null)
145                {
146                    rear++;
147                    Nodes[rear] = rootNode.RNode;
148                }
149            }
150        }
151        
152        #endregion
153
154        //测试的主方法#region 测试的主方法
155        static void Main(string[] args)
156        {
157            nodes<string> rootNode = BinTree();
158
159            Console.WriteLine("先序遍历方法遍历二叉树：");
160            PreOrder<string>(rootNode);
161           
162            Console.WriteLine("中序遍历方法遍历二叉树：");
163            MidOrder<string>(rootNode);
164            
165            Console.WriteLine("后序遍历方法遍历二叉树：");
166            AfterOrder<string>(rootNode);
167
168
169            Console.WriteLine("层次遍历方法遍历二叉树：");
170            LayerOrder<string>(rootNode);
171
172
173            Console.Read();
174
175        } 
176
177    }
178}
179