算法篇----二叉树遍历

本次的算法主要描述二叉树的遍历：

  
  

   
   using
   
    System;

   
   using
   
    System.Collections.Generic;

   
   namespace
   
    NET.MST.Thirteenth.BinaryTree
{
 
   
   class
   
    MainClass
 {
 
   
   ///
   
    
   
   <summary>
   
   
 
   
   ///
   
    测试二叉树，和其中序、后序遍历
 
   
   ///
   
    
   
   </summary>
   
   

   
    
   
   static
   
    
   
   void
   
    Main(
   
   string
   
   [] args)
 {
 
   
   int
   
   [] data 
   
   =
   
    
   
   new
   
    
   
   int
   
   [] { 
   
   6
   
   , 
   
   1
   
   , 
   
   3
   
   , 
   
   9
   
   , 
   
   2
   
   , 
   
   7
   
   , 
   
   11
   
    };
 BinaryTree root 
   
   =
   
    BinaryTree.GenerateBinaryTree(data);
 Console.Write(
   
   "
   
   中序遍历：
   
   "
   
   );
 root.InOrder();
 Console.Write(
   
   "
   
   \r\n
   
   "
   
   );
 Console.Write(
   
   "
   
   后序遍历：
   
   "
   
   );
 root.LastOrder();
 Console.Write(
   
   "
   
   \r\n
   
   "
   
   );
 Console.Read();
 }
 }
 
   
   ///
   
    
   
   <summary>
   
   
 
   
   ///
   
    二叉树的实现
 
   
   ///
   
    
   
   </summary>
   
   

   
    
   
   partial
   
    
   
   class
   
    BinaryTree
 {
 
   
   //
   
   左子树指针
   
   

   
    
   
   private
   
    BinaryTree _left 
   
   =
   
    
   
   null
   
   ;
 
   
   //
   
   右子树指针
   
   

   
    
   
   private
   
    BinaryTree _right 
   
   =
   
    
   
   null
   
   ;
 
   
   //
   
   节点的值，这里以整数表示
   
   

   
    
   
   private
   
    
   
   int
   
    _value;
 
   
   ///
   
    
   
   <summary>
   
   
 
   
   ///
   
    构造方法，左右子树设为null
 
   
   ///
   
    
   
   </summary>
   
   
 
   
   ///
   
    
   
   <param name="val">
   
   节点值
   
   </param>
   
   

   
    
   
   public
   
    BinaryTree(
   
   int
   
    val)
 {
 _value 
   
   =
   
    val;
 }
 
   
   ///
   
    
   
   <summary>
   
   
 
   
   ///
   
    构造方法
 
   
   ///
   
    
   
   </summary>
   
   
 
   
   ///
   
    
   
   <param name="val">
   
   节点值
   
   </param>
   
   
 
   
   ///
   
    
   
   <param name="left">
   
   左子树指针
   
   </param>
   
   
 
   
   ///
   
    
   
   <param name="right">
   
   右子树指针
   
   </param>
   
   

   
    
   
   public
   
    BinaryTree(
   
   int
   
    val, BinaryTree left, BinaryTree right)
 {
 _value 
   
   =
   
    val;
 _left 
   
   =
   
    left;
 _right 
   
   =
   
    right;
 }
 
   
   //
   
   读写属性
   
   

   
    
   
   public
   
    BinaryTree Left
 {
 
   
   get
   
   
 {
 
   
   return
   
    _left;
 }
 
   
   set
   
   
 {
 _left 
   
   =
   
    value;
 }
 }
 
   
   public
   
    BinaryTree Right
 {
 
   
   get
   
   
 {
 
   
   return
   
    _right;
 }
 
   
   set
   
   
 {
 _right 
   
   =
   
    value;
 }
 }
 
   
   public
   
    
   
   int
   
    Value
 {
 
   
   get
   
   
 {
 
   
   return
   
    _value;
 }
 
   
   set
   
   
 {
 _value 
   
   =
   
    value;
 }
 }
 }
 
   
   ///
   
    
   
   <summary>
   
   
 
   
   ///
   
    二叉树的生成和插入
 
   
   ///
   
    
   
   </summary>
   
   

   
    
   
   partial
   
    
   
   class
   
    BinaryTree
 {
 
   
   ///
   
    
   
   <summary>
   
   
 
   
   ///
   
    静态方法用以从一个数组生成一颗二叉树
 
   
   ///
   
    这里采用的是有序的插入
 
   
   ///
   
    
   
   </summary>
   
   
 
   
   ///
   
    
   
   <param name="data">
   
   输入数组
   
   </param>
   
   
 
   
   ///
   
    
   
   <returns>
   
   返回根节点
   
   </returns>
   
   

   
    
   
   public
   
    
   
   static
   
    BinaryTree GenerateBinaryTree(
   
   int
   
   [] data)
 {
 
   
   //
   
   确保数组非空
   
   

   
    
   
   if
   
    (data.Length 
   
   <=
   
    
   
   0
   
   )
 
   
   return
   
    
   
   null
   
   ;
 
   
   //
   
   生成根节点
   
   

   
    BinaryTree root 
   
   =
   
    
   
   new
   
    BinaryTree(data[
   
   0
   
   ]);
 
   
   //
   
   确保需要生成左子树或者右子树
   
   

   
    
   
   if
   
    (data.Length 
   
   <=
   
    
   
   1
   
   )
 
   
   return
   
    root;
 
   
   //
   
   逐一插入整个数组
   
   

   
    
   
   for
   
    (
   
   int
   
    i 
   
   =
   
    
   
   1
   
   ; i 
   
   <
   
    data.Length; i
   
   ++
   
   )
 root.InsertElement(data[i]);
 
   
   return
   
    root;
 }
 
   
   ///
   
    
   
   <summary>
   
   
 
   
   ///
   
    有序地插入元素，插入的结果是中序遍历该二叉树可以获得一个有序序列
 
   
   ///
   
    
   
   </summary>
   
   
 
   
   ///
   
    
   
   <param name="val">
   
   需要插入的值
   
   </param>
   
   

   
    
   
   public
   
    
   
   void
   
    InsertElement(
   
   int
   
    val)
 {
 
   
   //
   
   需要插在左子树中
   
   

   
    
   
   if
   
    (val 
   
   <=
   
    _value)
 {
 
   
   //
   
   左子树为空，插入新元素
   
   

   
    
   
   if
   
    (_left 
   
   ==
   
    
   
   null
   
   )
 {
 BinaryTree node 
   
   =
   
    
   
   new
   
    BinaryTree(val);
 _left 
   
   =
   
    node;
 }
 
   
   //
   
   左子树非空，递归
   
   

   
    
   
   else
   
   
 _left.InsertElement(val);
 }
 
   
   //
   
   需要插在右子树中
   
   

   
    
   
   else
   
   
 {
 
   
   //
   
   右子树为空，插入新元素
   
   

   
    
   
   if
   
    (_right 
   
   ==
   
    
   
   null
   
   )
 {
 BinaryTree node 
   
   =
   
    
   
   new
   
    BinaryTree(val);
 _right 
   
   =
   
    node;
 }
 
   
   //
   
   右子树非空，递归
   
   

   
    
   
   else
   
   
 _right.InsertElement(val);
 }
 }
 }
 
   
   ///
   
    
   
   <summary>
   
   
 
   
   ///
   
    遍历二叉树
 
   
   ///
   
    
   
   </summary>
   
   

   
    
   
   partial
   
    
   
   class
   
    BinaryTree
 {
 
   
   ///
   
    
   
   <summary>
   
   
 
   
   ///
   
    中序遍历二叉树
 
   
   ///
   
    
   
   </summary>
   
   

   
    
   
   public
   
    
   
   void
   
    InOrder()
 {
 
   
   //
   
   使用递归算法
   
   

   
    
   
   if
   
    (_left 
   
   !=
   
    
   
   null
   
   )
 _left.InOrder();
 Console.Write(
   
   "
   
   {0}，
   
   "
   
   , _value);
 
   
   if
   
    (_right 
   
   !=
   
    
   
   null
   
   )
 _right.InOrder();
 }
 
   
   ///
   
    
   
   <summary>
   
   
 
   
   ///
   
    后序遍历二叉树
 
   
   ///
   
    
   
   </summary>
   
   

   
    
   
   public
   
    
   
   void
   
    LastOrder()
 {
 
   
   //
   
   使用递归算法
   
   

   
    
   
   if
   
    (_left 
   
   !=
   
    
   
   null
   
   )
 _left.LastOrder();
 
   
   if
   
    (_right 
   
   !=
   
    
   
   null
   
   )
 _right.LastOrder();
 Console.Write(
   
   "
   
   {0}，
   
   "
   
   , _value);
 }
 }
}