C#二叉树遍历算法实现浅析

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