c#二叉树遍历 vs2008实现

下面简单介绍一下几种算法和思路：
先序遍历：
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

 下面只是做了一个中序遍历

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TreeNode_2008
{
        // Binary Tree的结点类 
        class Node
        {
            public  int Data { get; set; }
            public  Node LeftSubNode { get; set; }
            public  Node RightSubNode { get; set; }

            // 结点为自己追加子结点（与向左/向右追加结合，形成递归） 
            public void Append(Node subNode)
            {
                if (subNode.Data <= this.Data)
                {
                    this.AppendLeft(subNode);
                }
                else
                {
                    this.AppendRight(subNode);
                }
            }

            // 向左追加 
            public void AppendLeft(Node subNode)
            {
                if (this.LeftSubNode == null)
                {
                    this.LeftSubNode = subNode;
                }
                else
                {
                    this.LeftSubNode.Append(subNode);
                }
            }

            // 向右追加 
            public void AppendRight(Node subNode)
            {
                if (this.RightSubNode == null)
                {
                    this.RightSubNode = subNode;
                }
                else
                {
                    this.RightSubNode.Append(subNode);
                }
            }

            // 结点显示自己的数据 
            public void ShowData()
            {
                Console.WriteLine("Data={0}", this.Data);
            }
        }

        // Binary Tree类 
        class Tree
        {
            // 根结点 
            public Node Root { get; set; }

            // 以某结点为起点，插入结点 
            public void Insert(Node newNode)
            {
                if (this.Root == null)
                {
                    this.Root = newNode;
                }
                else
                {
                    this.Root.Append(newNode);
                }
            }

            // 重载，默认以根结点为起点插入 
            public void MidTravel()
            {
                this.MidTravel(this.Root);
            }

            // 中序遍历（递归） 
            public void MidTravel(Node node)
            {
                if (node.LeftSubNode != null)
                {
                    this.MidTravel(node.LeftSubNode);
                }

                node.ShowData();

                if (node.RightSubNode != null)
                {
                    this.MidTravel(node.RightSubNode);
                }
            }
        }

        class Program
        {
            static void Main(string[] args)
            {
                Tree tree = new Tree();

                tree.Insert(new Node { Data = 3 });
                tree.Insert(new Node { Data = 6 });
                tree.Insert(new Node { Data = 2 });
                tree.Insert(new Node { Data = 7 });
                tree.Insert(new Node { Data = 18 });

                tree.MidTravel();
                Console.Read();
            }
        }
    }