本程序中将用到一棵已知的二叉树如图(二叉树图)所示。
先序遍历:
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