2. 程式人生 > >二叉樹3種遍歷演算法遞迴與非遞迴實現詳解

二叉樹3種遍歷演算法遞迴與非遞迴實現詳解

阿新 • • 發佈：2019-01-23

一, 二叉樹先序遍歷的實現

  1.     遞迴實現
void PreOrderTraverse(BiTree T)
{


    if( T )
    {
        VisitF(T->data);//訪問根節點
        PreOrderTraverse(T->lchild);//遞迴左子樹
        PreOrderTraverse(T->rchild);//遞迴右子樹
    }
}

    2.   非遞迴實現

思路： 

  1. 判斷棧是否為空或子樹為空
  2. 若不為空，就訪問左孩子並將其入棧，直至左孩子為空
  3. 若左孩子為空，就出棧，然後訪問右孩子，入棧，就這樣不斷的迴圈。
void PreOrderTraverse_Nonrecursion(BiTree T)
{
    LiStack  S ;
    BiTree  p ;
    S = NULL ;
    p = T ;

    InitStack(S) ;

    if(NULL == p)
    {
        printf("樹為空！\n") ;
        return ;
    }

    while(p || !StackEmpty(S))
    {
        if(p)
        {
            Push(S, p) ;
            VisitF(p->data);
            p = p->lchild ;
        }
        else
        {
            Pop(S, p) ;
            p = p->rchild ;
        }
    }

    free(S) ;
}

二,  二叉樹中序遍歷的實現

  1.     遞迴實現
/*
    中序遍歷二叉樹
*/
void InOrderTraverse(BiTree T)
{

    if( T )
    {
        InOrderTraverse(T->lchild);
        VisitF(T->data);
        InOrderTraverse(T->rchild);
    }
}

      2.    非遞迴實現

思路：思路基本和先序差不多，只是輸出資料的時候不一樣

  1. 判斷棧和樹是否為空，

  2. 若不，則判斷樹是否為空，

  3. 不為繼續將左子樹進棧，若為空，則出棧，輸出資料，然後訪問右子樹。

void InOrderTraverse_Nonrecursion(BiTree T)
{
    LiStack  S ;
    BiTree  p ;
    S = NULL ;
    p = T ;

    InitStack(S) ;

    if(NULL == p)
    {
        printf("樹為空！\n") ;
        return ;
    }

    while(p || !StackEmpty(S))
    {
        if(p)
        {
            Push(S, p) ;

            p = p->lchild ;
        }
        else
        {
            Pop(S, p) ;
            VisitF(p->data);
            p = p->rchild ;
        }
    }

    free(S) ;
}

三,  二叉樹中序遍歷的實現

  1.  遞迴實現
/*
    後續遍歷二叉樹
*/
void PostOrderTraverse(BiTree T)
{

    if( T )
    {
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        VisitF(T->data);
    }
}

 2. 非遞迴實現

思路 ：實現有多多種方法，有兩個棧，或加標誌位實現，但是我覺得如下實現最容易懂

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

void PostOrderTraverse_Nonrecursion(BiTree T)
{
    LiStack  S ;
    BiTree  cur, pre ;
    S = NULL ;
    InitStack(S) ;
    if(NULL == T)
    {
        printf("樹為空！\n") ;
        return ;
    }

    pre = NULL ;
    cur = NULL ;
    Push(S,T) ;
    while(!StackEmpty(S))
    {
        cur = NULL ;
        GetTop(S,cur) ;
        if((cur->lchild == NULL && cur->rchild == NULL) || (pre != NULL && (pre == cur->lchild ||pre == cur->rchild)))
        {
            VisitF(cur->data);
            pre = cur ;
            Pop(S,cur) ;
        }
        else
        {
            if(cur->rchild != NULL)
            {
                Push(S,cur->rchild) ;
            }
            if(cur->lchild != NULL)
            {
                Push(S,cur->lchild) ;
            }
        }
    }
    free(S) ;
}

如下是完整程式碼：

#include<stdio.h>
#include<stdlib.h>

#define OK 1
#define ERROR -1

typedef char TElemType;

typedef int Status;

typedef struct BiTNode
{

    TElemType data;
    struct BiTNode *lchild,*rchild;

} BiTNode,*BiTree;


typedef BiTNode * StackElemType;

typedef struct LinkNode    //棧的節點
{
    StackElemType data ;
    LinkNode * next ;
} LinkNode,*LiStack;

typedef BiTNode * QueueElemType ;     //定義佇列包含的資料型別

typedef struct QNode     //定義佇列節點
{
    QueueElemType  data ;
    struct QNode * next ;
} QNode,*QueuePtr;

typedef struct
{
    QueuePtr fronts;
    QueuePtr rears;
} LinkQueue;



Status creatBiTree(BiTree &T);

void Visit(char ch,int level);

void PreOrderTraverse(BiTree T,int level);

void InOrderTraverse(BiTree T,int level);

void PostOrderTraverse(BiTree T,int level);

Status  InitStack(LiStack &S);

void Push(LiStack &S, StackElemType data);

void Pop(LiStack & S, StackElemType &data);

int StackEmpty(LiStack  &S);

int GetTop(LiStack &S, StackElemType & data);

Status InitQueue(LinkQueue &Q);

Status EnQueue(LinkQueue &Q, QueueElemType data);

Status DeQueue(LinkQueue &Q, QueueElemType & data);

int QueueEmpty(LinkQueue Q);

void PreOrderTraverse_Nonrecursion(BiTree T);

void InOrderTraverse_Nonrecursion(BiTree T);

void PostOrderTraverse_Nonrecursion(BiTree T);



/*********************************************************************/
/*****************************棧的方法********************************/
//棧的函式定義
Status  InitStack(LiStack &S)
{
    S = (LinkNode *)malloc(sizeof(LinkNode)) ;
    if(NULL == S)
    {
        printf("記憶體不足，不能分配棧！\n") ;
        exit(0) ;
    }

    S->next = NULL ;
}

void Push(LiStack &S, StackElemType data)
{
    LiStack q ;
    q = (LinkNode *)malloc(sizeof(LinkNode)) ;
    if(NULL == q)
    {
        printf("記憶體不足，不能分配棧！\n") ;
        exit(0) ;
    }

    /*
        插入順序相當於頭插法.
    */
    q->data = data ;
    q->next = S->next ;
    S->next = q ;
}

void Pop(LiStack & S, StackElemType &data)
{
    LiStack  q;
    if(NULL == S->next)
    {
        printf("棧為空，無返回值！\n") ;
    }

    q = S->next ;
    data = q->data ;
    S->next = q->next ;
    free(q) ;
}


int StackEmpty(LiStack  &S)
{
    if(NULL == S->next)
    {
        return(1) ;
    }

    return(0) ;
}

int GetTop(LiStack &S, StackElemType & data)
{
    if(NULL != S->next)
    {
        data = S->next->data ;
        return(1) ;
    }
    else
    {
        //data = NULL ;
        return(0) ;
    }
}

/*********************************************************************/




/*****************************佇列的方法******************************/


//佇列函式的定義
Status InitQueue(LinkQueue &Q)
{
    Q.fronts = Q.rears = (QNode *)malloc(sizeof(QNode)) ;
    if(NULL == Q.fronts)
    {
        printf("記憶體不足！\n") ;
        return ERROR;
    }

    Q.fronts->next = NULL;

}

Status EnQueue(LinkQueue &Q, QueueElemType data)
{
    QueuePtr q ;
    q = (QNode*)malloc(sizeof(QNode));

    if(NULL == q)
    {
        printf("記憶體不足！\n") ;
        return ERROR;
    }

    //構造q
    q->data = data ;
    q->next = NULL;


    q->next = Q.rears->next ;
    Q.rears = q ;

    return OK;
}

Status DeQueue(LinkQueue &Q, QueueElemType & data)
{
    QueuePtr  p ;
    if(Q.fronts == Q.rears)
    {
        printf("佇列為空！\n") ;
        return ERROR ;
    }


    p = Q.fronts->next ;
    data = p->data ;


    Q.fronts->next = p->next ;
    if(Q.rears == p)
        Q.rears = Q.fronts ;

    free(p);

    return OK;
}

int QueueEmpty(LinkQueue Q)
{
    if(Q.fronts == Q.rears)
        return(1) ;
    else
        return(0) ;
}

/*********************************************************************/








/*
   先序建立二叉樹
*/
Status creatBiTree(BiTree &T)
{
    char ch;

    scanf("%c",&ch);

    if('@' == ch)
    {
        T = NULL;
    }
    else
    {

        //申請失敗
        if(!(T = (BiTNode*)malloc(sizeof(BiTNode))))
            return ERROR;

        T->data = ch;

        creatBiTree(T->lchild);
        creatBiTree(T->rchild);
    }



    return OK;
}

void VisitF(char ch)
{
    printf("%c  ",ch);
}

void Visit(char ch,int level)
{

    printf("%c 位於第 %d 層 \n",ch,level);

}


/*
    先序遍歷二叉樹
*/
void PreOrderTraverse(BiTree T,int level)
{



    if( T )
    {
        VisitF(T->data);
        PreOrderTraverse(T->lchild,++level);
        PreOrderTraverse(T->rchild,++level);
    }
}

void PreOrderTraverse_Nonrecursion(BiTree T)
{
    LiStack  S ;
    BiTree  p ;
    S = NULL ;
    p = T ;

    InitStack(S) ;

    if(NULL == p)
    {
        printf("樹為空！\n") ;
        return ;
    }

    while(p || !StackEmpty(S))
    {
        if(p)
        {
            Push(S, p) ;
            VisitF(p->data);
            p = p->lchild ;
        }
        else
        {
            Pop(S, p) ;
            p = p->rchild ;
        }
    }

    free(S) ;
}


/*
    中序遍歷二叉樹
*/
void InOrderTraverse(BiTree T)
{

    if( T )
    {
        InOrderTraverse(T->lchild);
        VisitF(T->data);
        InOrderTraverse(T->rchild);
    }
}

void InOrderTraverse_Nonrecursion(BiTree T)
{
    LiStack  S ;
    BiTree  p ;
    S = NULL ;
    p = T ;

    InitStack(S) ;

    if(NULL == p)
    {
        printf("樹為空！\n") ;
        return ;
    }

    while(p || !StackEmpty(S))
    {
        if(p)
        {
            Push(S, p) ;

            p = p->lchild ;
        }
        else
        {
            Pop(S, p) ;
            VisitF(p->data);
            p = p->rchild ;
        }
    }

    free(S) ;
}


/*
    後續遍歷二叉樹
*/
void PostOrderTraverse(BiTree T)
{

    if( T )
    {
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        VisitF(T->data);
    }
}

void PostOrderTraverse_Nonrecursion(BiTree T)
{
    LiStack  S ;
    BiTree  cur, pre ;
    S = NULL ;
    InitStack(S) ;
    if(NULL == T)
    {
        printf("樹為空！\n") ;
        return ;
    }

    pre = NULL ;
    cur = NULL ;
    Push(S,T) ;
    while(!StackEmpty(S))
    {
        cur = NULL ;
        GetTop(S,cur) ;
        if((cur->lchild == NULL && cur->rchild == NULL) || (pre != NULL && (pre == cur->lchild ||pre == cur->rchild)))
        {
            VisitF(cur->data);
            pre = cur ;
            Pop(S,cur) ;
        }
        else
        {
            if(cur->rchild != NULL)
            {
                Push(S,cur->rchild) ;
            }
            if(cur->lchild != NULL)
            {
                Push(S,cur->lchild) ;
            }
        }
    }
    free(S) ;
}

int main()
{
    int level = 1;
    BiTree T = NULL;

    creatBiTree(T);

    printf("先序遍歷二叉樹，每個結點在第幾行\n");
    PreOrderTraverse(T,level);

    printf("\n\n");
    printf("先序遍歷二叉樹,非遞迴演算法\n");

    PreOrderTraverse_Nonrecursion(T);
    printf("\n\n\n");

    /***************************************************/


    printf("中序遍歷二叉樹\n");
    InOrderTraverse(T);

    printf("\n\n");
    printf("中序遍歷二叉樹,非遞迴演算法\n");

    InOrderTraverse_Nonrecursion(T);
    printf("\n\n\n");

    /***************************************************/

    printf("後序遍歷二叉樹\n");
    PostOrderTraverse(T);

    printf("\n\n");
    printf("後序遍歷二叉樹,非遞迴演算法\n");

    PostOrderTraverse_Nonrecursion(T);
    printf("\n\n\n");

    return 0;
}

相關推薦

二叉樹3種遍歷演算法遞迴與非遞迴實現詳解

一, 二叉樹先序遍歷的實現     遞迴實現 void PreOrderTraverse(BiTree T) { if( T ) { VisitF(T->data);//訪問根節點 PreOrderTra

Java實現二叉樹三種遍歷演算法

</pre><p></p><p>參考網上一些資料測試整理了一下二叉樹遍歷的Java實現程式碼。</p>二叉樹三種遍歷方式：先序遍歷、中序遍歷、後序遍歷。<p>首先定義二叉樹類：</p>&l

二叉樹幾種遍歷演算法

<span style="font-size:14px;">/*二叉樹的遍歷*/ #include <iostream> #include <cstring> #include <stack> using namespace

（1）建立二叉樹的二叉連結串列。 （2）寫出對用二叉連結串列儲存的二叉樹進行先序、中序和後序遍歷的遞迴和非遞迴演算法。 （3）寫出對用二叉連結串列儲存的二叉樹進行層次遍歷演算法。 （4）求二叉樹的所有葉子及結點總數。

（1）建立二叉樹的二叉連結串列。 （2）寫出對用二叉連結串列儲存的二叉樹進行先序、中序和後序遍歷的遞迴和非遞迴演算法。 （3）寫出對用二叉連結串列儲存的二叉樹進行層次遍歷演算法。（4）求二叉樹的所有葉子及結點總數。 include<stdio.h> #inclu

二叉樹三種遍歷非遞迴演算法

1.先序遍歷非遞迴演算法 #define maxsize 100 typedef struct {     Bitree Elem[maxsize];     int top; } SqStack; void PreOrderUnrec(Bitree t) {     SqStack s;     Stack

資料結構例程 二叉樹的層次遍歷演算法

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

二叉樹 ADT介面 遍歷演算法 常規運算

BTree.h   (結構定義, 基本操作, 遍歷） 1 #define MS 10 2 3 typedef struct BTreeNode{ 4 char data; 5 struct BTreeNode *

二叉樹三種遍歷方式

二叉樹的遍歷，如果是手工畫圖，還可以使用投影法快速得到遍歷序列。 以下圖二叉樹為例，講解投影法快速得到遍歷序列的過程。 （1）          中序遍歷 中序遍歷就像在無風的情況下，太陽直射

【圖解資料結構】 一組動畫徹底理解二叉樹三種遍歷

二叉樹的遍歷是指從根結點出發，按照某種次序依次訪問二叉樹中所有結點，使得每個結點被訪問一次且僅被訪問一次。 在二叉樹的遍歷中存在三種較為常用的遍歷方式：前序遍歷、中序遍歷、後序遍歷。接下來我將嘗試著用三組動畫向讀者詳細的介紹這三種遍歷方式的邏輯思路，希望讓讀者看到任何的二叉樹都能在腦海中快速的勾勒出動畫。

二叉樹幾種遍歷方式之間的轉換

寫在前面 二叉樹的遍歷方式，基本可以歸結為四種：前序遍歷、中序遍歷、後序遍歷、層次遍歷 先序遍歷順序：根，左兒子，右兒子 中序遍歷順序：左兒子，根，右兒子 後序遍歷順序：左兒子，右兒子，根 層次遍歷順序：根據每一層的順序，由左向右依次輸出 遍歷順序及轉換  &n

樹和二叉樹3——各種遍歷輸出二叉樹

程式碼輸出結果如下： 二叉樹 bt:A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I))) ***層次遍歷序列:A B C D E F G H I J K L M N 先序遍歷序列: 遞迴演算法:A B D E H J K L M N C F G I 非遞迴演算法:A B

二叉樹三種遍歷方式及通過兩種遍歷重構二叉樹（java實現）

重構方法參考文章【重構二叉樹（Java實現）：https://blog.csdn.net/wangbingcsu/article/details/51372695】 文章目錄 二叉樹類 三種遍歷方式 前序遍歷 中序遍歷 後序遍歷

資料結構例程——二叉樹的層次遍歷演算法

【二叉樹的層次遍歷演算法】 　　實現二叉樹的層次遍歷演算法，並對用”A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))”建立的二叉樹進行測試。 　　請利用二叉樹演算法

二叉樹的各種遍歷演算法C++實現

大概在網上摘抄和總結了二叉樹的幾種遍歷方法，有遞迴和非遞迴的，先貼在這裡，用的時候在來看看。再次謝謝網上的各種資源。謝謝CSDN博主SJF0115，謝謝劍指offer作者何海濤~ #include"stdafx.h" #include<iostream>

二叉樹的各種遍歷演算法以及例項

一、二叉樹 在電腦科學中，樹是一種重要的非線性資料結構，直觀地看，它是資料元素（在樹中稱為結點）按分支關係組織起來的結構。二叉樹是每個節點最多有兩個子樹的有序樹。通常子樹被稱作“左子樹”（left subtree）和“右子樹”（right subtree）。二叉樹常被用於實

二叉樹三種遍歷方式的遞迴和迴圈實現

轉載自：http://blog.csdn.net/pi9nc/article/details/13008511 二叉樹是一種非常重要的資料結構，很多其他資料機構都是基於二叉樹的基礎演變過來的。二叉樹有前、中、後三種遍歷方式，因為樹的本身就是用遞迴定義的，因此採用遞迴的方

二叉樹三種遍歷六種實現

二叉樹是一種非常重要的資料結構，很多其他資料機構都是基於二叉樹的基礎演變過來的。二叉樹有前、中、後三種遍歷方式，因為樹的本身就是用遞迴定義的，因此採用遞迴的方法實現三種遍歷，不僅程式碼簡潔且容易理解，但其開銷也比較大，而若採用非遞迴方法實現三種遍歷，則要用棧來模擬實現

二叉樹三種遍歷遞迴及非遞迴實現

二叉樹的三種遍歷方式包括： 前序遍歷中序遍歷後序遍歷 三種遍歷的遞迴方法都非常好實現，而且簡單易懂。非遞迴實現也是通過使用棧來模擬遍歷的過程。順便提一句，能用遞迴做的，基本都能用棧來實現。前序遍歷和中序遍歷的非遞迴寫法相對比較簡單，只需要模擬遍歷過程即可。後序遍歷非遞迴寫

二叉樹四種遍歷方式的速度差異

同學阿里三面面試官的一道面試題是：二叉樹每個節點都儲存一個整數，想要求所有節點數值之和，哪種遍歷方式最快？ 首先定義二叉樹 struct Tree { int val; Tree *left; Tree *right; Tre

二叉樹三種遍歷 (Java)

以前學資料結構的時候是用C學的，現在重新複習一下資料結構裡用的比較多的二叉樹，用Java實現。好啦，廢話不多說啦！！ 我們知道二叉樹有三種遍歷方式：前序(根左右)、中序(左根右)、後序(左右根)。每種遍歷方式其實就是一個遞迴呼叫。 步驟： 1、將陣列中的元素賦值給二叉樹（通