c# 二叉树

最新推荐文章于 2020-01-19 18:42:46 发布

dooooooooit

最新推荐文章于 2020-01-19 18:42:46 发布

阅读量385

点赞数

分类专栏：数据结构文章标签： c# 数据结构 null 测试 string c

数据结构专栏收录该内容

3 篇文章 0 订阅

订阅专栏

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

先序遍历：

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

 
   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
 

dooooooooit

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
c# 二叉树

本程序中将用到一棵已知的二叉树如图（二叉树图）所示。先序遍历：1. 访问根结点2. 按先序遍历左子树;3. 按先序遍历右子树；4. 例如：遍历已知二叉树结果为：A->B->D->G->H->C->E->F中序遍历：1. 按中序遍历左子树;2. 访问根结点；3. 按中序遍历右子树
复制链接

扫一扫

专栏目录