二叉樹的深度優先遍歷、廣度優先遍歷和非遞歸遍歷

二叉樹的遍歷：

D：訪問根結點，L：遍歷根結點的左子樹，R：遍歷根結點的右子樹。

給定一棵二叉樹的前序遍歷序列和中序遍歷序列可以惟一確定一棵二叉樹。

二叉樹的深度優先遍歷的非遞歸的通用做法是採用棧，廣度優先遍歷的非遞歸的通用做法是採用隊列。

深度優先遍歷二叉樹。

1. 中序遍歷（LDR）的遞歸算法：

若二叉樹爲空，則算法結束；否則：

    中序遍歷根結點的左子樹；

    訪問根結點；

    中序遍歷根結點的右子樹。

2. 前序遍歷（DLR）的遞歸算法：

若二叉樹爲空，則算法結束，否則：

    訪問根結點；

    前序遍歷根結點的左子樹；

    前序遍歷根結點的右子樹。

3. 後序遍歷（LRD）的遞歸算法：

若二叉樹爲空，則算法結束，否則：

    後序遍歷根結點的左子樹；

    後序遍歷根結點的右子樹；

    訪問根結點。

 

廣度優先遍歷二叉樹。

廣度優先周遊二叉樹(層序遍歷)是用隊列來實現的，從二叉樹的第一層（根結點）開始，自上至下逐層遍歷；在同一層中，按照從左到右的順序對結點逐一訪問。

按照從根結點至葉結點、從左子樹至右子樹的次序訪問二叉樹的結點。算法：

    1初始化一個隊列，並把根結點入列隊；

    2當隊列爲非空時，循環執行步驟3到步驟5，否則執行6；

    3出隊列取得一個結點，訪問該結點；

    4若該結點的左子樹爲非空，則將該結點的左子樹入隊列；

    5若該結點的右子樹爲非空，則將該結點的右子樹入隊列；

    6結束。

 

非遞歸深度優先遍歷二叉樹。

棧是實現遞歸的最常用的結構，利用一個棧來記下尚待遍歷的結點或子樹，以備以後訪問，可以將遞歸的深度優先遍歷改爲非遞歸的算法。

1. 非遞歸前序遍歷：遇到一個結點，就訪問該結點，並把此結點推入棧中，然後下降去遍歷它的左子樹。遍歷完它的左子樹後，從棧頂托出這個結點，並按照它的右鏈接指示的地址再去遍歷該結點的右子樹結構。

2. 非遞歸中序遍歷：遇到一個結點，就把它推入棧中，並去遍歷它的左子樹。遍歷完左子樹後，從棧頂托出這個結點並訪問之，然後按照它的右鏈接指示的地址再去遍歷該結點的右子樹。

3. 非遞歸後序遍歷：遇到一個結點，把它推入棧中，遍歷它的左子樹。遍歷結束後，還不能馬上訪問處於棧頂的該結點，而是要再按照它的右鏈接結構指示的地址去遍歷該結點的右子樹。遍歷遍右子樹後才能從棧頂托出該結點並訪問之。另外，需要給棧中的每個元素加上一個特徵位，以便當從棧頂托出一個結點時區別是從棧頂元素左邊回來的(則要繼續遍歷右子樹)，還是從右邊回來的(該結點的左、右子樹均已周遊)。特徵爲Left表示已進入該結點的左子樹，將從左邊回來；特徵爲Right表示已進入該結點的右子樹，將從右邊回來。

4. 簡潔的非遞歸前序遍歷：遇到一個結點，就訪問該結點，並把此結點的非空右結點推入棧中，然後下降去遍歷它的左子樹。遍歷完左子樹後，從棧頂托出一個結點，並按照它的右鏈接指示的地址再去遍歷該結點的右子樹結構。

----------------------------------------------------------------------

    圖的深度優先搜索法是樹的先根遍歷的推廣，它的基本思想是：從圖G的某個頂點v0出發，訪問v0，然後選擇一個與v0相鄰且沒被訪問過的頂點vi訪問，再從vi出發選擇一個與vi相鄰且未被訪問的頂點vj進行訪問，依次繼續。如果當前被訪問過的頂點的所有鄰接頂點都已被訪問，則退回到已被訪問的頂點序列中最後一個擁有未被訪問的相鄰頂點的頂點w，從w出發按同樣的方法向前遍歷，直到圖中所有頂點都被訪問。

    圖的廣度優先搜索是樹的按層次遍歷的推廣，它的基本思想是：首先訪問初始點vi，並將其標記爲已訪問過，接着訪問vi的所有未被訪問過的鄰接點vi1,vi2, …, vi t，並均標記已訪問過，然後再按照vi1,vi2, …, vi t的次序，訪問每一個頂點的所有未被訪問過的鄰接點，並均標記爲已訪問過，依次類推，直到圖中所有和初始點vi有路徑相通的頂點都被訪問過爲止。

#include<iostream>
#include<queue>
#include<stack>
using namespace std;
//二叉樹結點的描述
typedef struct BiTNode
{
    char data;
    struct BiTNode *lchild, *rchild;      //左右孩子
}BiTNode,*BiTree;
//按先序遍歷創建二叉樹
//BiTree *CreateBiTree()     //返回結點指針類型
//void CreateBiTree(BiTree &root)      //引用類型的參數
void CreateBiTree(BiTNode **root)    //二級指針作爲函數參數
{
    char ch; //要插入的數據
    scanf("\n%c", &ch);
    //cin>>ch;
    if(ch=='#')
        *root = NULL;
    else
    {
        *root = (BiTNode *)malloc(sizeof(BiTNode));
        (*root)->data = ch;
        printf("請輸入%c的左孩子：",ch);
        CreateBiTree(&((*root)->lchild));
        printf("請輸入%c的右孩子：",ch);
        CreateBiTree(&((*root)->rchild));
    }
}
//前序遍歷的算法程序
void PreOrder(BiTNode *root)
{
    if(root==NULL)
        return ;
    printf("%c ", root->data); //輸出數據
    PreOrder(root->lchild); //遞歸調用，前序遍歷左子樹
    PreOrder(root->rchild); //遞歸調用，前序遍歷右子樹
}
//中序遍歷的算法程序
void InOrder(BiTNode *root)
{
    if(root==NULL)
        return ;
    InOrder(root->lchild); //遞歸調用，前序遍歷左子樹
    printf("%c ", root->data); //輸出數據
    InOrder(root->rchild); //遞歸調用，前序遍歷右子樹
}
//後序遍歷的算法程序
void PostOrder(BiTNode *root)
{
    if(root==NULL)
        return ;
    PostOrder(root->lchild);      //遞歸調用，前序遍歷左子樹
    PostOrder(root->rchild);      //遞歸調用，前序遍歷右子樹
    printf("%c ", root->data);    //輸出數據  
}
/*
二叉樹的非遞歸前序遍歷，前序遍歷思想：先讓根進棧，只要棧不爲空，就可以做彈出操作，
每次彈出一個結點，記得把它的左右結點都進棧，記得右子樹先進棧，這樣可以保證右子樹在棧中總處於左子樹的下面。
*/
void PreOrder_Nonrecursive2(BiTree T)     //先序遍歷的非遞歸  
{
    if(!T)  
        return ;  
  
    stack<BiTree> s;
    s.push(T);
    while(!s.empty())
    {
        BiTree temp = s.top();
        cout<<temp->data<<" ";
        s.pop();
        if(temp->rchild)
            s.push(temp->rchild);
        if(temp->lchild)
            s.push(temp->lchild);
    }
}
void PreOrder_Nonrecursive(BiTree T)     //先序遍歷的非遞歸
{
    if(!T)
        return ;
    stack<BiTree> s;
    while(T)          // 左子樹上的節點全部壓入到棧中
    {
        s.push(T);
        cout<<T->data<<"  ";
        T = T->lchild;
    }
    
    while(!s.empty())
    {        
        BiTree temp = s.top()->rchild;  // 棧頂元素的右子樹
        s.pop();                        // 彈出棧頂元素
        while(temp)          // 棧頂元素存在右子樹，則對右子樹同樣遍歷到最下方
        {
            cout<<temp->data<<"  ";
            s.push(temp);
            temp = temp->lchild;
        }
    }
}
void InOrderTraverse(BiTree T)   // 中序遍歷的非遞歸
{
    if(!T)
        return ;
    stack<BiTree> S;
    BiTree curr = T->lchild;    // 指向當前要檢查的節點
    S.push(T);
    while(curr != NULL || !S.empty())
    {
        while(curr != NULL)    // 一直向左走
        {
            S.push(curr);
            curr = curr->lchild;
        }
        curr = S.top();
        S.pop();
        cout<<curr->data<<"  ";
        curr = curr->rchild;
    }
}
void PostOrder_Nonrecursive(BiTree T)  // 後序遍歷的非遞歸  
{  
    stack<BiTree> S;  
    BiTree curr = T ;           // 指向當前要檢查的節點
    BiTree previsited = NULL;    // 指向前一個被訪問的節點
    while(curr != NULL || !S.empty())  // 棧空時結束  
    {  
        while(curr != NULL)            // 一直向左走直到爲空
        {  
            S.push(curr);  
            curr = curr->lchild;  
        }  
        curr = S.top();
        // 當前節點的右孩子如果爲空或者已經被訪問，則訪問當前節點
        if(curr->rchild == NULL || curr->rchild == previsited)  
        {  
            cout<<curr->data<<"  ";  
            previsited = curr;  
            S.pop();  
            curr = NULL;  
        }  
        else
            curr = curr->rchild;      // 否則訪問右孩子
    }  
} 
void PostOrder_Nonrecursive(BiTree T)  // 後序遍歷的非遞歸     雙棧法
{  
    stack<BiTree> s1 , s2;  
    BiTree curr ;           // 指向當前要檢查的節點
    s1.push(T);
    while(!s1.empty())  // 棧空時結束  
    {
        curr = s1.top();
        s1.pop();
        s2.push(curr);
        if(curr->lchild)
            s1.push(curr->lchild);
        if(curr->rchild)
            s1.push(curr->rchild);
    }
    while(!s2.empty())
    {
        printf("%c ", s2.top()->data);
        s2.pop();
    }
}
int visit(BiTree T)
{
    if(T)
    {
        printf("%c ",T->data);
        return 1;
    }
    else
        return 0;
}
void LeverTraverse(BiTree T)   //方法一、非遞歸層次遍歷二叉樹 
{
    queue <BiTree> Q;
    BiTree p;
    p = T;
    if(visit(p)==1)
        Q.push(p);
    while(!Q.empty())
    {
        p = Q.front();
        Q.pop();
        if(visit(p->lchild) == 1) 
            Q.push(p->lchild);
        if(visit(p->rchild) == 1)
            Q.push(p->rchild);
    }
}
void LevelOrder(BiTree BT)     //方法二、非遞歸層次遍歷二叉樹 
{
    BiTNode *queue[10];//定義隊列有十個空間
    if (BT==NULL)
        return;
    int front,rear;
    front=rear=0;
    queue[rear++]=BT;
    while(front!=rear)//如果隊尾指針不等於對頭指針時
    {
        cout<<queue[front]->data<<"  ";  //輸出遍歷結果
        if(queue[front]->lchild!=NULL)  //將隊首結點的左孩子指針入隊列
        {
            queue[rear]=queue[front]->lchild;
            rear++;    //隊尾指針後移一位
        }
        if(queue[front]->rchild!=NULL)
        {
            queue[rear]=queue[front]->rchild;    //將隊首結點的右孩子指針入隊列
            rear++;   //隊尾指針後移一位
        }
        front++;    //對頭指針後移一位
    }
}
int depth(BiTNode *T)   //樹的深度
{
    if(!T)
        return 0;
    int d1,d2;
    d1=depth(T->lchild);
    d2=depth(T->rchild);
    return (d1>d2?d1:d2)+1;
    //return (depth(T->lchild)>depth(T->rchild)?depth(T->lchild):depth(T->rchild))+1;
}
int CountNode(BiTNode *T)
{
    if(T == NULL)
        return 0;
    return 1+CountNode(T->lchild)+CountNode(T->rchild);
}
int main(void)
{
    BiTNode *root=NULL; //定義一個根結點
    int flag=1,k;
    printf("                     本程序實現二叉樹的基本操作。\n");
    printf("可以進行建立二叉樹，遞歸先序、中序、後序遍歷，非遞歸先序、中序遍歷及非遞歸層序遍歷等操作。\n");
    while(flag)
    {
        printf("\n");
        printf("|--------------------------------------------------------------|\n");
        printf("|                    二叉樹的基本操作如下:                     |\n");
        printf("|                        0.創建二叉樹                          |\n");
        printf("|                        1.遞歸先序遍歷                        |\n");
        printf("|                        2.遞歸中序遍歷                        |\n");
        printf("|                        3.遞歸後序遍歷                        |\n");
        printf("|                        4.非遞歸先序遍歷                      |\n");
        printf("|                        5.非遞歸中序遍歷                      |\n");
        printf("|                        6.非遞歸後序遍歷                      |\n");
        printf("|                        7.非遞歸層序遍歷                      |\n");
        printf("|                        8.二叉樹的深度                        |\n");
        printf("|                        9.二叉樹的結點個數                    |\n");
        printf("|                        10.退出程序                            |\n");
        printf("|--------------------------------------------------------------|\n");
        printf("                        請選擇功能：");
        scanf("%d",&k);
        switch(k)
        {
        case 0:
            printf("請建立二叉樹並輸入二叉樹的根節點：");
            CreateBiTree(&root);
            break;
        case 1:
            if(root)
            {
                printf("遞歸先序遍歷二叉樹的結果爲：");
                PreOrder(root);
                printf("\n");
            }
            else
                printf("          二叉樹爲空！\n");
            break;
        case 2:
            if(root)
            {
                printf("遞歸中序遍歷二叉樹的結果爲：");
                InOrder(root);
                printf("\n");
            }
            else
                printf("          二叉樹爲空！\n");
            break;
        case 3:
            if(root)
            {
                printf("遞歸後序遍歷二叉樹的結果爲：");
                PostOrder(root);
                printf("\n");
            }
            else
                printf("          二叉樹爲空！\n");
            break;
        case 4:
            if(root)
            {
                printf("非遞歸先序遍歷二叉樹：");
                PreOrder_Nonrecursive(root);
                printf("\n");
            }
            else
                printf("          二叉樹爲空！\n");
            break;
        case 5:
            if(root)
            {
                printf("非遞歸中序遍歷二叉樹：");
                InOrderTraverse(root);
                printf("\n");
            }
            else
                printf("          二叉樹爲空！\n");
            break;
        case 6:
            if(root)
            {
                printf("非遞歸後序遍歷二叉樹：");
                PostOrder_Nonrecursive(root);
                printf("\n");
            }
            else
                printf("          二叉樹爲空！\n");
            break;
        case 7:
            if(root)
            {
                printf("非遞歸層序遍歷二叉樹：");
                //LeverTraverse(root);
                LevelOrder(root);
                printf("\n");
            }
            else
                printf("          二叉樹爲空！\n");
            break;
        case 8:
            if(root)
                printf("這棵二叉樹的深度爲：%d\n",depth(root));
            else
                printf("          二叉樹爲空！\n");
            break;
        case 9:
            if(root)
                printf("這棵二叉樹的結點個數爲：%d\n",CountNode(root));
            else
                printf("          二叉樹爲空！\n");
            break;
        default:
            flag=0;
            printf("程序運行結束，按任意鍵退出！\n");
        }
    }
    system("pause");
    return 0;
}

運行效果圖如下：

分別輸入：
1
2
4
#
#
5
#
#
3
6
#
#
7
#
# 
就可以構造如下圖所示的二叉樹了。。

後序遍歷非遞歸的另外一種寫法：

複製代碼代碼如下:

    /* 
    後序遍歷由於遍歷父節點是在遍歷子節點之後，而且左節點和右節點遍歷後的行爲不一樣， 
    所以需要用變量來記錄前一次訪問的節點，根據前一次節點和現在的節點的關係來確定具體執行什麼操作 
    */  
    void Postorder(BiTree T)  
    {  
        if(T == NULL)  
            return ;  
        stack<BiTree> s;  
        BiTree prev = NULL , curr = NULL;  
        s.push(T);  
        while(!s.empty())  
        {  
            curr = s.top();  
            if(prev == NULL  || prev->lchild == curr || prev->rchild == curr)  
            {  
                if(curr->lchild != NULL)  
                    s.push(curr->lchild);  
                else if(curr->rchild != NULL)  
                    s.push(curr->rchild);  
            }  
            else if(curr->lchild == prev)  
            {  
                if(curr->rchild != NULL)  
                    s.push(curr->rchild);  
            }  
            else  
            {  
                cout<<curr->data;  
                s.pop();  
            }  
            prev = curr;  
        }  
    }  

輸入二叉樹中的兩個節點，輸出這兩個結點在數中最低的共同父節點。
思路：遍歷二叉樹，找到一條從根節點開始到目的節點的路徑，然後在兩條路徑上查找共同的父節點。

複製代碼代碼如下:

    // 得到一條從根節點開始到目的節點的路徑  
    bool GetNodePath(TreeNode *pRoot , TreeNode *pNode , vector<TreeNode *> &path)  
    {  
        if(pRoot == NULL)  
            return false;  
        if(pRoot == pNode)  
            return true;  
        else if(GetNodePath(pRoot->lchild , pNode , path) )  
        {  
            path.push_back(pRoot->lchild);  
            return true;  
        }  
        else if(GetNodePath(pRoot->rchild , pNode , path) )  
        {  
            path.push_back(pRoot->rchild);  
            return true;  
        }  
        return false;  
    }  
    TreeNode *GetLastCommonNode(const vector<TreeNode *> &path1 , const vector<TreeNode *> &path2)  
    {  
        vector<TreeNode *>::const_iterator iter1 = path1.begin();  
        vector<TreeNode *>::const_iterator iter2 = path2.begin();  
        TreeNode *pLast;  
        while(iter1 != path1.end() && iter2 != path2.end() )  
        {  
            if(*iter1 == *iter2)  
                pLast = *iter1;  
            else  
                break;  
            iter1++;  
            iter2++;  
        }  
        return pLast;  
    }  
    TreeNode *GetLastCommonParent(TreeNode *pRoot , TreeNode *pNode1 , TreeNode *pNode2)  
    {  
        if(pRoot == NULL || pNode1 == NULL || pNode2 == NULL)  
            return  NULL;  
        vector<TreeNode *> path1;  
        GetNodePath(pRoot , pNode1 , path1);  

        vector<TreeNode *> path2;  
        GetNodePath(pRoot , pNode2 , path2);  
        return GetLastCommonNode(path1 , path2);  
    }