CSDN博客

img alice_art

c# 二叉树

发表于2008/9/28 2:10:00  745人阅读

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

先序遍历:

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



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

阅读全文
0 0

相关文章推荐

img
取 消
img