C#算法實現了二叉樹的定義，怎么構造一顆已知的二叉樹，用幾種常規的算法（先序，中序，后序，層次）進行C#二叉樹遍歷。希望能給有需要人帶來幫助，也希望能得到大家的指點。有關C#數據結構的書在書店里找到，網上也是極少，如果你有好的學習資源別忘了告訴我。先謝了。數據結構對一個程序員來說，現在是太重要了，數據結構學得好的人，邏輯思維一定很強，在程序設計的時候，就不會覺得太費勁了。而且是在設計多層應用程序的時候，真是讓人絞盡腦汁啊。趁自己還年輕，趕緊練練腦子。哈哈，咱們盡快進入主題吧。

本程序中將用到一棵已知的二叉樹如圖（二叉樹圖）所示。

下面簡單介紹一下幾種算法和思路：

◆C#二叉樹遍歷算法之先序遍歷：

1.訪問根結點

2.按先序遍歷左子樹;

3.按先序遍歷右子樹；

4.例如：遍歷已知二叉樹結果為：A-﹥B-﹥D-﹥G-﹥H-﹥C-﹥E-﹥F

◆C#二叉樹遍歷算法之中序遍歷：

1.按中序遍歷左子樹;

2.訪問根結點；

3.按中序遍歷右子樹；

4.例如遍歷已知二叉樹的結果：B-﹥G-﹥D-﹥H-﹥A-﹥E-﹥C-﹥F

◆C#二叉樹遍歷算法之后序遍歷：

1.按后序遍歷左子樹；

2.按后序遍歷右子樹；

3.訪問根結點；

4.例如遍歷已知二叉樹的結果：G-﹥H-﹥D-﹥B-﹥E-﹥F-﹥C-﹥A

◆C#二叉樹遍歷算法之層次遍歷：

1.從上到下，從左到右遍歷二叉樹的各個結點(實現時需要借輔助容器)；

2.例如遍歷已知二叉樹的結果：A-﹥B-﹥C-﹥D-﹥E-﹥F-﹥G-﹥H

以下是整個二叉遍歷算法解決方案的代碼：

using System;  
using System.Collections.Generic;  
using System.Text;  
 
namespace structure  
{  
    class Program  
    {  
        #region 二叉樹結點數據結構的定義   
        //二叉樹結點數據結構包括數據域，左右結點以及父結點成員；  
      class nodes﹤T﹥  
        {  
            T data;  
            nodes﹤T﹥ Lnode, Rnode, Pnode;  
            public T Data  
            {  
                set { data = value; }  
                get { return data; }  
 
            }  
            public nodes﹤T﹥ LNode  
            {  
                set { Lnode = value; }  
                get { return Lnode; }  
            }  
            public nodes﹤T﹥ RNode  
            {  
                set { Rnode = value; }  
                get { return Rnode; }  
 
            }  
 
            public nodes﹤T﹥ PNode  
            {  
                set { Pnode = value; }  
                get { return Pnode; }  
 
            }  
          public nodes()  
          { }  
          public nodes(T data)  
          {  
              this.data = data;  
          }  
 
        }   
        #endregion  
 
        #region 先序編歷二叉樹  
        static void PreOrder﹤T﹥(nodes﹤T﹥ rootNode)  
        {  
            if (rootNode != null)  
            {  
                Console.WriteLine(rootNode.Data);  
                PreOrder﹤T﹥(rootNode.LNode);  
                PreOrder﹤T﹥(rootNode.RNode);  
 
            }  
        }  
          
        #endregion  
 
        #region 構造一棵已知的二叉樹  
 
        static nodes﹤string﹥ BinTree()  
        {  
            nodes﹤string﹥[] binTree = new nodes﹤string﹥[8];  
            //創建結點  
            binTree[0] = new nodes﹤string﹥("A");  
            binTree[1] = new nodes﹤string﹥("B");  
            binTree[2] = new nodes﹤string﹥("C");  
            binTree[3] = new nodes﹤string﹥("D");  
            binTree[4] = new nodes﹤string﹥("E");  
            binTree[5] = new nodes﹤string﹥("F");  
            binTree[6] = new nodes﹤string﹥("G");  
            binTree[7] = new nodes﹤string﹥("H");  
            //使用層次遍歷二叉樹的思想，構造一個已知的二叉樹  
 
            binTree[0].LNode = binTree[1];  
            binTree[0].RNode = binTree[2];  
            binTree[1].RNode = binTree[3];  
            binTree[2].LNode = binTree[4];  
            binTree[2].RNode = binTree[5];  
            binTree[3].LNode = binTree[6];  
            binTree[3].RNode = binTree[7];  
            //返回二叉樹的根結點  
            return binTree[0];  
 
        }  
        #endregion  
 
        #region 中序遍歷二叉樹  
        static void MidOrder﹤T﹥(nodes﹤T﹥ rootNode)  
        {  
            if (rootNode != null)  
            {  
                MidOrder﹤T﹥(rootNode.LNode);  
                Console.WriteLine(rootNode.Data);  
                MidOrder﹤T﹥(rootNode.RNode);  
            }  
        }   
        #endregion  
        后序遍歷二叉樹#region 后序遍歷二叉樹  
        static void AfterOrder﹤T﹥(nodes﹤T﹥ rootNode)  
        {  
            if (rootNode != null)  
            {  
                AfterOrder﹤T﹥(rootNode.LNode);  
                AfterOrder﹤T﹥(rootNode.RNode);  
                Console.WriteLine(rootNode.Data);  
            }  
 
        }   
        #endregion  
 
       #region 層次遍歷二叉樹  
        static void LayerOrder﹤T﹥(nodes﹤T﹥ rootNode)  
        {  
            nodes﹤T﹥[] Nodes = new nodes﹤T﹥[20];  
            int front = -1;  
            int rear = -1;  
            if (rootNode != null)  
            {  
                rear++;  
                Nodes[rear] = rootNode;  
 
            }  
 
            while (front != rear)  
            {  
                front++;  
                rootNode = Nodes[front];  
                Console.WriteLine(rootNode.Data);  
                if (rootNode.LNode != null)  
                {  
                    rear++;  
                    Nodes[rear] = rootNode.LNode;  
                }  
                if (rootNode.RNode != null)  
                {  
                    rear++;  
                    Nodes[rear] = rootNode.RNode;  
                }  
            }  
        }  
          
        #endregion  
 
      #region 測試的主方法  
        static void Main(string[] args)  
        {  
            nodes﹤string﹥ rootNode = BinTree();  
 
            Console.WriteLine("先序遍歷方法遍歷二叉樹：");  
            PreOrder﹤string﹥(rootNode);  
             
            Console.WriteLine("中序遍歷方法遍歷二叉樹：");  
            MidOrder﹤string﹥(rootNode);  
              
            Console.WriteLine("后序遍歷方法遍歷二叉樹：");  
            AfterOrder﹤string﹥(rootNode);  
 
 
            Console.WriteLine("層次遍歷方法遍歷二叉樹：");  
            LayerOrder﹤string﹥(rootNode);  
 
 
            Console.Read();  
 
        }   
        #endregion  
    }  
} 

C#二叉樹遍歷算法實現就向你介紹到這里，希望通過對C#二叉樹遍歷算法實現的講解使你對C#算法有了一些認識。

【編輯推薦】

1. C#算法解決的一道面試題
2. C#算法實現字符串反轉淺析
3. C#算法解決蘿卜地問題
4. C#九九乘法表的實現淺析
5. C#算法應用之高斯消元法實現