二叉樹的六種遍歷方法彙總（轉）

時間  2019-12-10
標籤 二叉樹 遍歷 方法 彙總 欄目 應用數學 简体版
原文   原文鏈接

原文地址 ，兩種思路都不錯html

第一種

前序

void preOrder(Node *p) //非遞歸
{
   if(!p) return;
   stack<Node*> s;
   Node *t;
   s.push(p);
   while(!s.empty())
   {
       t=s.top();
       printf("%d\n",t->data);
       s.pop();
       if(t->right) s.push(t->right);
       if(t->left) s.push(t->left);
    }
 }


中序

void inOrder(Node *p)
{
     if(!p)
         return;
     stack< pair<Node*,int> > s;
     Node *t;
     int unUsed;
     s.push(make_pair(p,1));
     while(!s.empty())
     {
         t=s.top().first;
         unUsed = s.top().second;
         s.pop();
         if(unUsed)
         {
               if(t->right)
                     s.push( make_pair(t->right,1) );
              s.push( make_pair(t,0) );
              if(t->left)
                     s.push( make_pair(t->left,1));
          }
          else printf("%d\n",t->data);
       }
}

 

後序

void postOrder(Node *p)
{
    if(!p) return;
    stack<pair<Node*,int> > s;
    Node *t;
    int unUsed;
    s.push(make_pair(p,1));
    while(!s.empty())
    {
        t=s.top().first;
        unUsed=s.top().second;
        s.pop();
        if(unUsed)
        {
            s.push(make_pair(t,0);
            if(t->right)
                s.push(make_pair(t->right,1));
            if(t->left)
                s.push(make_pair(t->left,1));
        }
        else printf("%d\n",t->data);
    }
}

 

 

 

第二種

二叉樹的非遞歸遍歷node

         二叉樹是一種很是重要的數據結構，不少其它數據結構都是基於二叉樹的基礎演變而來的。對於二叉樹，有前序、中序以及後序三種遍歷方法。由於樹的定義自己就是遞歸定義，所以採用遞歸的方法去實現樹的三種遍歷不只容易理解並且代碼很簡潔。而對於樹的遍歷若採用非遞歸的方法，就要採用棧去模擬實現。在三種遍歷中，前序和中序遍歷的非遞歸算法都很容易實現，非遞歸後序遍歷實現起來相對來講要難一點。ios

一.前序遍歷

   前序遍歷按照「根結點-左孩子-右孩子」的順序進行訪問。算法

   1.遞歸實現數據結構

void preOrder1(BinTree *root)     //遞歸前序遍歷 
{
    if(root!=NULL)
    {
        cout<<root->data<<" ";
        preOrder1(root->lchild);
        preOrder1(root->rchild);
    }
}

 

   2.非遞歸實現post

    根據前序遍歷訪問的順序，優先訪問根結點，而後再分別訪問左孩子和右孩子。即對於任一結點，其可看作是根結點，所以能夠直接訪問，訪問完以後，若其左孩子不爲空，按相同規則訪問它的左子樹；當訪問其左子樹時，再訪問它的右子樹。所以其處理過程以下：spa

     對於任一結點P：code

     1)訪問結點P，並將結點P入棧;htm

     2)判斷結點P的左孩子是否爲空，若爲空，則取棧頂結點並進行出棧操做，並將棧頂結點的右孩子置爲當前的結點P，循環至1);若不爲空，則將P的左孩子置爲當前的結點P;blog

     3)直到P爲NULL而且棧爲空，則遍歷結束。

void preOrder2(BinTree *root)     //非遞歸前序遍歷 
{
    stack<BinTree*> s;
    BinTree *p=root;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            cout<<p->data<<" ";
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty())
        {
            p=s.top();
            s.pop();
            p=p->rchild;
        }
    }
}

 

二.中序遍歷

    中序遍歷按照「左孩子-根結點-右孩子」的順序進行訪問。

    1.遞歸實現

void inOrder1(BinTree *root)      //遞歸中序遍歷
{
    if(root!=NULL)
    {
        inOrder1(root->lchild);
        cout<<root->data<<" ";
        inOrder1(root->rchild);
    }
}

 

   2.非遞歸實現

    根據中序遍歷的順序，對於任一結點，優先訪問其左孩子，而左孩子結點又能夠看作一根結點，而後繼續訪問其左孩子結點，直到遇到左孩子結點爲空的結點才進行訪問，而後按相同的規則訪問其右子樹。所以其處理過程以下：

   對於任一結點P，

  1)若其左孩子不爲空，則將P入棧並將P的左孩子置爲當前的P，而後對當前結點P再進行相同的處理；

  2)若其左孩子爲空，則取棧頂元素並進行出棧操做，訪問該棧頂結點，而後將當前的P置爲棧頂結點的右孩子；

  3)直到P爲NULL而且棧爲空則遍歷結束

void inOrder2(BinTree *root)      //非遞歸中序遍歷
{
    stack<BinTree*> s;
    BinTree *p=root;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty())
        {
            p=s.top();
            cout<<p->data<<" ";
            s.pop();
            p=p->rchild;
        }
    }    
}

 

  三.後序遍歷

      後序遍歷按照「左孩子-右孩子-根結點」的順序進行訪問。

      1.遞歸實現

void postOrder1(BinTree *root)    //遞歸後序遍歷
{
    if(root!=NULL)
    {
        postOrder1(root->lchild);
        postOrder1(root->rchild);
        cout<<root->data<<" ";
    }    
}

 

      2.非遞歸實現

       後序遍歷的非遞歸實現是三種遍歷方式中最難的一種。由於在後序遍歷中，要保證左孩子和右孩子都已被訪問而且左孩子在右孩子前訪問才能訪問根結點，這就爲流程的控制帶來了難題。下面介紹兩種思路。

      第一種思路：對於任一結點P，將其入棧，而後沿其左子樹一直往下搜索，直到搜索到沒有左孩子的結點，此時該結點出如今棧頂，可是此時不能將其出棧並訪問，所以其右孩子還爲被訪問。因此接下來按照相同的規則對其右子樹進行相同的處理，當訪問完其右孩子時，該結點又出如今棧頂，此時能夠將其出棧並訪問。這樣就保證了正確的訪問順序。能夠看出，在這個過程當中，每一個結點都兩次出如今棧頂，只有在第二次出如今棧頂時，才能訪問它。所以須要多設置一個變量標識該結點是不是第一次出如今棧頂。

void postOrder2(BinTree *root)    //非遞歸後序遍歷
{
    stack<BTNode*> s;
    BinTree *p=root;
    BTNode *temp;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)              //沿左子樹一直往下搜索，直至出現沒有左子樹的結點 
        {
            BTNode *btn=(BTNode *)malloc(sizeof(BTNode));
            btn->btnode=p;
            btn->isFirst=true;
            s.push(btn);
            p=p->lchild;
        }
        if(!s.empty())
        {
            temp=s.top();
            s.pop();
            if(temp->isFirst==true)     //表示是第一次出如今棧頂 
             {
                temp->isFirst=false;
                s.push(temp);
                p=temp->btnode->rchild;    
            }
            else                        //第二次出如今棧頂 
             {
                cout<<temp->btnode->data<<" ";
                p=NULL;
            }
        }
    }    
}

 

        第二種思路：要保證根結點在左孩子和右孩子訪問以後才能訪問，所以對於任一結點P，先將其入棧。若是P不存在左孩子和右孩子，則能夠直接訪問它；或者P存在左孩子或者右孩子，可是其左孩子和右孩子都已被訪問過了，則一樣能夠直接訪問該結點。若非上述兩種狀況，則將P的右孩子和左孩子依次入棧，這樣就保證了每次取棧頂元素的時候，左孩子在右孩子前面被訪問，左孩子和右孩子都在根結點前面被訪問。

void postOrder3(BinTree *root)     //非遞歸後序遍歷
{
    stack<BinTree*> s;
    BinTree *cur;                      //當前結點 
    BinTree *pre=NULL;                 //前一次訪問的結點 
    s.push(root);
    while(!s.empty())
    {
        cur=s.top();
        if((cur->lchild==NULL&&cur->rchild==NULL)||
           (pre!=NULL&&(pre==cur->lchild||pre==cur->rchild)))
        {
            cout<<cur->data<<" ";  //若是當前結點沒有孩子結點或者孩子節點都已被訪問過 
              s.pop();
            pre=cur; 
        }
        else
        {
            if(cur->rchild!=NULL)
                s.push(cur->rchild);
            if(cur->lchild!=NULL)    
                s.push(cur->lchild);
        }
    }    
}

 

 四.整個程序完整的代碼

/*二叉樹的遍歷* 2011.8.25*/ 

#include <iostream>
#include<string.h>
#include<stack> 
using namespace std;

typedef struct node
{
    char data;
    struct node *lchild,*rchild;
}BinTree;

typedef struct node1
{
    BinTree *btnode;
    bool isFirst;
}BTNode;


void creatBinTree(char *s,BinTree *&root)  //建立二叉樹，s爲形如A(B,C(D,E))形式的字符串 
{
    int i;
    bool isRight=false;
    stack<BinTree*> s1;          //存放結點 
    stack<char> s2;              //存放分隔符
    BinTree *p,*temp;
    root->data=s[0];
    root->lchild=NULL;
    root->rchild=NULL;
    s1.push(root);
    i=1;
    while(i<strlen(s))
    {
        if(s[i]=='(')
        {
            s2.push(s[i]);
            isRight=false;
        }    
        else if(s[i]==',')    
        {
            isRight=true;
        }
        else if(s[i]==')')
        {
            s1.pop();
            s2.pop();
        }
        else if(isalpha(s[i]))
        {
            p=(BinTree *)malloc(sizeof(BinTree));
            p->data=s[i];
            p->lchild=NULL;
            p->rchild=NULL;
            temp=s1.top();
            if(isRight==true)    
            {
                temp->rchild=p;
                cout<<temp->data<<"的右孩子是"<<s[i]<<endl;
            }
            else
            {
                temp->lchild=p;
                cout<<temp->data<<"的左孩子是"<<s[i]<<endl;
            }
            if(s[i+1]=='(')
                s1.push(p);
        }
        i++;
    }    
}

void display(BinTree *root)        //顯示樹形結構 
{
    if(root!=NULL)
    {
        cout<<root->data;
        if(root->lchild!=NULL)
        {
            cout<<'(';
            display(root->lchild);
        }
        if(root->rchild!=NULL)
        {
            cout<<',';
            display(root->rchild);
            cout<<')';
        }
    }
}

void preOrder1(BinTree *root)     //遞歸前序遍歷 
{
    if(root!=NULL)
    {
        cout<<root->data<<" ";
        preOrder1(root->lchild);
        preOrder1(root->rchild);
    }
}

void inOrder1(BinTree *root)      //遞歸中序遍歷
{
    if(root!=NULL)
    {
        inOrder1(root->lchild);
        cout<<root->data<<" ";
        inOrder1(root->rchild);
    }
} 

void postOrder1(BinTree *root)    //遞歸後序遍歷
{
    if(root!=NULL)
    {
        postOrder1(root->lchild);
        postOrder1(root->rchild);
        cout<<root->data<<" ";
    }    
} 

void preOrder2(BinTree *root)     //非遞歸前序遍歷 
{
    stack<BinTree*> s;
    BinTree *p=root;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            cout<<p->data<<" ";
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty())
        {
            p=s.top();
            s.pop();
            p=p->rchild;
        }
    }
}

void inOrder2(BinTree *root)      //非遞歸中序遍歷
{
    stack<BinTree*> s;
    BinTree *p=root;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty())
        {
            p=s.top();
            cout<<p->data<<" ";
            s.pop();
            p=p->rchild;
        }
    }    
} 

void postOrder2(BinTree *root)    //非遞歸後序遍歷
{
    stack<BTNode*> s;
    BinTree *p=root;
    BTNode *temp;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)              //沿左子樹一直往下搜索，直至出現沒有左子樹的結點 
         {
            BTNode *btn=(BTNode *)malloc(sizeof(BTNode));
            btn->btnode=p;
            btn->isFirst=true;
            s.push(btn);
            p=p->lchild;
        }
        if(!s.empty())
        {
            temp=s.top();
            s.pop();
            if(temp->isFirst==true)     //表示是第一次出如今棧頂 
             {
                temp->isFirst=false;
                s.push(temp);
                p=temp->btnode->rchild;    
            }
            else                        //第二次出如今棧頂 
             {
                cout<<temp->btnode->data<<" ";
                p=NULL;
            }
        }
    }    
} 

void postOrder3(BinTree *root)     //非遞歸後序遍歷
{
    stack<BinTree*> s;
    BinTree *cur;                      //當前結點 
    BinTree *pre=NULL;                 //前一次訪問的結點 
    s.push(root);
    while(!s.empty())
    {
        cur=s.top();
        if((cur->lchild==NULL&&cur->rchild==NULL)||
           (pre!=NULL&&(pre==cur->lchild||pre==cur->rchild)))
        {
            cout<<cur->data<<" ";  //若是當前結點沒有孩子結點或者孩子節點都已被訪問過 
              s.pop();
            pre=cur; 
        }
        else
        {
            if(cur->rchild!=NULL)
                s.push(cur->rchild);
            if(cur->lchild!=NULL)    
                s.push(cur->lchild);
        }
    }    
}


int main(int argc, char *argv[])
{
    char s[100];
    while(scanf("%s",s)==1)
    {
        BinTree *root=(BinTree *)malloc(sizeof(BinTree));
        creatBinTree(s,root);
        display(root);
        cout<<endl;
        preOrder2(root);
        cout<<endl; 
        inOrder2(root);
        cout<<endl;
        postOrder2(root);
        cout<<endl;
        postOrder3(root);
        cout<<endl;
    }
    return 0;
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程