C# 遍历二叉树

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