帶你一文看懂二叉樹的先（中、後）序遍歷以及層次遍歷（圖解+遞歸/非遞歸代碼實現）

原創 飞猪飞飞 2020-06-16 07:48

工科生一枚，熱衷於底層技術開發，有強烈的好奇心，感興趣內容包括單片機，嵌入式Linux，Uboot等，歡迎學習交流！
愛好跑步，打籃球，睡覺。
歡迎加我QQ1500836631（備註CSDN），一起學習交流問題，分享各種學習資料，電子書籍，學習視頻等。

文章目錄

先序遍歷

先序遍歷規則

  先序遍歷的核心思想：1.訪問根節點；2.訪問當前節點的左子樹；3.若當前節點無左子樹，則訪問當前節點的右子樹；即考察到一個節點後，即刻輸出該節點的值，並繼續遍歷其左右子樹。(根左右)

先序遍歷舉例

  如圖所示，採用先序遍歷訪問這顆二叉樹的詳細過程爲：
  1.訪問該二叉樹的根節點，找到 1；
  2.訪問節點 1 的左子樹，找到節點 2；
  3.訪問節點 2 的左子樹，找到節點 4；
  4.由於訪問節點 4 左子樹失敗，且也沒有右子樹，因此以節點 4 爲根節點的子樹遍歷完成。但節點 2 還沒有遍歷其右子樹，因此現在開始遍歷，即訪問節點 5；
  5.由於節點 5 無左右子樹，因此節點 5 遍歷完成，並且由此以節點 2 爲根節點的子樹也遍歷完成。現在回到節點 1 ，並開始遍歷該節點的右子樹，即訪問節點 3；
  6.訪問節點 3 左子樹，找到節點 6；
  7.由於節點 6 無左右子樹，因此節點 6 遍歷完成，回到節點 3 並遍歷其右子樹，找到節點 7；
  8.節點 7 無左右子樹，因此以節點 3 爲根節點的子樹遍歷完成，同時迴歸節點 1。由於節點 1 的左右子樹全部遍歷完成，因此整個二叉樹遍歷完成；
在這裏插入圖片描述

先序遍歷代碼（遞歸）

/*
 * @Description: 
 * @Version: 
 * @Autor: Carlos
 * @Date: 2020-05-29 16:55:41
 * @LastEditors: Carlos
 * @LastEditTime: 2020-05-30 17:03:23
 */ 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define TElemType int
//構造結點的結構體
typedef struct BiTNode{
    TElemType data;//數據域
    struct BiTNode *lchild,*rchild;//左右孩子指針
}BiTNode,*BiTree;

/**
 * @Description: 初始化樹的函數
 * @Param: BiTree *T 結構體指針的指針
 * @Return: 無
 * @Author: Carlos
 */
void CreateBiTree(BiTree *T){
    *T=(BiTree)malloc(sizeof(BiTNode));
    //根節點
    (*T)->data=1;
    (*T)->lchild=(BiTree)malloc(sizeof(BiTNode));
    (*T)->rchild=(BiTree)malloc(sizeof(BiTNode));
    //1節點的左孩子2
    (*T)->lchild->data=2;
    (*T)->lchild->lchild=(BiTree)malloc(sizeof(BiTNode));
    (*T)->lchild->rchild=(BiTree)malloc(sizeof(BiTNode));
    //2節點的右孩子5
    (*T)->lchild->rchild->data=5;
    (*T)->lchild->rchild->lchild=NULL;
    (*T)->lchild->rchild->rchild=NULL;
    //1節點的右孩子3
    (*T)->rchild->data=3;
    (*T)->rchild->lchild=(BiTree)malloc(sizeof(BiTNode));
    //3節點的左孩子6
    (*T)->rchild->lchild->data=6;
    (*T)->rchild->lchild->lchild=NULL;
    (*T)->rchild->lchild->rchild=NULL;
    (*T)->rchild->rchild=(BiTree)malloc(sizeof(BiTNode));
    //3節點的右孩子7
    (*T)->rchild->rchild->data=7;
    (*T)->rchild->rchild->lchild=NULL;
    (*T)->rchild->rchild->rchild=NULL;
    //2節點的左孩子4
    (*T)->lchild->lchild->data=4;
    (*T)->lchild->lchild->lchild=NULL;
    (*T)->lchild->lchild->rchild=NULL;
}


/**
 * @Description: 模擬操作結點元素的函數，輸出結點本身的數值
 * @Param:BiTree elem 就結構體指針
 * @Return: 無
 * @Author: Carlos
 */
void PrintBiT(BiTree elem){
    printf("%d ",elem->data);
}

/**
 * @Description: 先序遍歷
 * @Param: BiTree T 結構體指針
 * @Return: 無
 * @Author: Carlos
 */
void PreOrderTraverse(BiTree T){
    if (T) {
        PrintBiT(T);//調用操作結點數據的函數方法
        PreOrderTraverse(T->lchild);//訪問該結點的左孩子
        PreOrderTraverse(T->rchild);//訪問該結點的右孩子
    }
    //如果結點爲空，返回上一層
    return;
}
int main() {
    BiTree Tree;
    CreateBiTree(&Tree);
    printf("先序遍歷: \n");
    PreOrderTraverse(Tree);
}

先序遍歷代碼（非遞歸）

  因爲要在遍歷完某個樹的根節點的左子樹後接着遍歷節點的右子樹，爲了能找到該樹的根節點，需要使用棧來進行暫存。中序和後序也都涉及到回溯，所以都需要用到棧。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define TElemType int
//構造結點的結構體
typedef struct BiTNode{
    TElemType data;//數據域
    struct BiTNode *lchild,*rchild;//左右孩子指針
}BiTNode,*BiTree;
int top = -1;
//定義一個順序棧
BiTree  a[20];
/**
 * @Description: 初始化樹
 * @Param: BiTree *T 指針的指針
 * @Return: 無
 * @Author: Carlos
 */
void CreateBiTree(BiTree *T){
    *T=(BiTree)malloc(sizeof(BiTNode));
    //根節點
    (*T)->data=1;
    (*T)->lchild=(BiTree)malloc(sizeof(BiTNode));
    (*T)->rchild=(BiTree)malloc(sizeof(BiTNode));
    //1節點的左孩子2
    (*T)->lchild->data=2;
    (*T)->lchild->lchild=(BiTree)malloc(sizeof(BiTNode));
    (*T)->lchild->rchild=(BiTree)malloc(sizeof(BiTNode));
    //2節點的右孩子5
    (*T)->lchild->rchild->data=5;
    (*T)->lchild->rchild->lchild=NULL;
    (*T)->lchild->rchild->rchild=NULL;
    //1節點的右孩子3
    (*T)->rchild->data=3;
    (*T)->rchild->lchild=(BiTree)malloc(sizeof(BiTNode));
    //3節點的左孩子6
    (*T)->rchild->lchild->data=6;
    (*T)->rchild->lchild->lchild=NULL;
    (*T)->rchild->lchild->rchild=NULL;
    (*T)->rchild->rchild=(BiTree)malloc(sizeof(BiTNode));
    //3節點的右孩子7
    (*T)->rchild->rchild->data=7;
    (*T)->rchild->rchild->lchild=NULL;
    (*T)->rchild->rchild->rchild=NULL;
    //2節點的左孩子4
    (*T)->lchild->lchild->data=4;
    (*T)->lchild->lchild->lchild=NULL;
    (*T)->lchild->lchild->rchild=NULL;
}
/**
 * @Description: 打印二叉樹
 * @Param: BiTree elem 指針的指針
 * @Return: 無
 * @Author: Carlos
 */
void PrintBiT(BiTree elem){
    printf("%d ",elem->data);
}
/**
 * @Description: 二叉樹壓棧函數
 * @Param: BiTree* a 結構體指針的指針（也可以理解爲指針數組） BiTree elem 結構體指針
 * @Return: 無
 * @Author: Carlos
 */
void Push(BiTree* a,BiTree elem)
{
     a[++top]=elem;
}
/**
 * @Description: 二叉樹彈棧函數
 * @Param: 無
 * @Return: 無
 * @Author: Carlos
 */
void Pop()
{
    if (top==-1) {
        return ;
    }
    top--;
}
/**
 * @Description: 獲取棧頂元素
 * @Param: BiTree*a 結構體指針數組
 * @Return: 結構體指針
 * @Author: Carlos
 */
BiTree GetTop(BiTree*a){
    return a[top];
}
/**
 * @Description: 先序遍歷
 * @Param: BiTree Tree 結構體指針
 * @Return: 無
 * @Author: Carlos
 */
void PreOrderTraverse(BiTree Tree)
{
   //臨時指針
    BiTree p;
    //根結點進棧
    Push(a, Tree);
    while (top!=-1) {
        //取棧頂元素
        p=GetTop(a);
        //彈棧
        Pop();
        while (p) {
            //調用結點的操作函數
            PrintBiT(p);
            //如果該結點有右孩子，右孩子進棧
            if (p->rchild) {
                Push(a,p->rchild);
            }
            p=p->lchild;//一直指向根結點最後一個左孩子
        }
    }
}
int main() {
    BiTree Tree;
    CreateBiTree(&Tree);
    printf("先序遍歷: \n");
    PreOrderTraverse(Tree);
    
}

中序遍歷

中序遍歷規則

  二叉樹中序遍歷的實現思想是：1.訪問當前節點的左子樹；2.訪問根節點；3.訪問當前節點的右子樹。即考察到一個節點後，將其暫存，遍歷完左子樹後，再輸出該節點的值，然後遍歷右子樹。(左根右)

中序遍歷舉例

在這裏插入圖片描述
  以上圖爲例，採用中序遍歷的思想遍歷該二叉樹的過程爲：
  1.訪問該二叉樹的根節點，找到 1；
  2.遍歷節點 1 的左子樹，找到節點 2；
  3.遍歷節點 2 的左子樹，找到節點 4；
  4.由於節點 4 無左孩子，因此找到節點 4，並遍歷節點 4 的右子樹；
  5.由於節點 4 無右子樹，因此節點 2 的左子樹遍歷完成，訪問節點 2；
  6.遍歷節點 2 的右子樹，找到節點 5；
  7.由於節點 5 無左子樹，因此訪問節點 5 ，又因爲節點 5 沒有右子樹，因此節點 1 的左子樹遍歷完成，訪問節點 1 ，並遍歷節點 1 的右子樹，找到節點 3；
  8.遍歷節點 3 的左子樹，找到節點 6；
  9.由於節點 6 無左子樹，因此訪問節點 6，又因爲該節點無右子樹，因此節點 3 的左子樹遍歷完成，開始訪問節點 3 ，並遍歷節點 3 的右子樹，找到節點 7；
  10.由於節點 7 無左子樹，因此訪問節點 7，又因爲該節點無右子樹，因此節點 1 的右子樹遍歷完成，即整棵樹遍歷完成；
  因此，上圖中二叉樹採用中序遍歷得到的序列爲：4 2 5 1 6 3 7

中序遍歷代碼（遞歸）

/*
 * @Description: 遞歸實現的中序遍歷
 * @Version: V1.0
 * @Autor: Carlos
 * @Date: 2020-05-18 14:53:29
 * @LastEditors: Carlos
 * @LastEditTime: 2020-05-30 17:21:06
 */ 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define TElemType int
//構造結點的結構體
typedef struct BiTNode{
    //數據域
    TElemType data;
    //左右孩子指針
    struct BiTreelchild,*rchild;
}BiTNode,*BiTree;
/**
 * @Description: 初始化樹
 * @Param: BiTree *T  結構體指針的指針（指針數組）
 * @Return: 無
 * @Author: Carlos
 */
void CreateBiTree(BiTree *T){
    *T=(BiTree)malloc(sizeof(BiTNode));
    (*T)->data=1;
    (*T)->lchild=(BiTree)malloc(sizeof(BiTNode));
    (*T)->rchild=(BiTree)malloc(sizeof(BiTNode));
  
    (*T)->lchild->data=2;
    (*T)->lchild->lchild=(BiTree)malloc(sizeof(BiTNode));
    (*T)->lchild->rchild=(BiTree)malloc(sizeof(BiTNode));
    (*T)->lchild->rchild->data=5;
    (*T)->lchild->rchild->lchild=NULL;
    (*T)->lchild->rchild->rchild=NULL;
    (*T)->rchild->data=3;
    (*T)->rchild->lchild=(BiTree)malloc(sizeof(BiTNode));
    (*T)->rchild->lchild->data=6;
    (*T)->rchild->lchild->lchild=NULL;
    (*T)->rchild->lchild->rchild=NULL;
    (*T)->rchild->rchild=(BiTree)malloc(sizeof(BiTNode));
    (*T)->rchild->rchild->data=7;
    (*T)->rchild->rchild->lchild=NULL;
    (*T)->rchild->rchild->rchild=NULL;
    (*T)->lchild->lchild->data=4;
    (*T)->lchild->lchild->lchild=NULL;
    (*T)->lchild->lchild->rchild=NULL;
}
/**
 * @Description: 顯示函數
 * @Param: BiTree elem 結構體指針
 * @Return: 無
 * @Author: Carlos
 */
void PrintBiT(BiTree elem){
    printf("%d ",elem->data);
}
/**
 * @Description: 中序遍歷
 * @Param: BiTree T 結構體指針
 * @Return: 無
 * @Author: Carlos
 */
void INOrderTraverse(BiTree T){
    if (T) {
        INOrderTraverse(T->lchild);//遍歷左孩子
        PrintBiT(T);//調用操作結點數據的函數方法
        INOrderTraverse(T->rchild);//遍歷右孩子
    }
    //如果結點爲空，返回上一層
    return;
}

int main() {
    BiTree Tree;
    CreateBiTree(&Tree);
    printf("中序遍歷算法: \n");
    INOrderTraverse(Tree);
}

中序遍歷代碼（非遞歸）

  和非遞歸先序遍歷類似，唯一區別是考查到當前節點時，並不直接輸出該節點。而是當考查節點爲空時，從棧中彈出的時候再進行輸出(永遠先考慮左子樹，直到左子樹爲空才訪問根節點)。

/*
 * @Description: 二叉樹的先序遍歷（非遞歸）
 * @Version: V1.0
 * @Autor: Carlos
 * @Date: 2020-05-17 16:35:27
 * @LastEditors: Carlos
 * @LastEditTime: 2020-05-18 14:51:01
 */ 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define DBG_PRINTF(fmt, args...)  \
do\
{\
    printf("<<File:%s  Line:%d  Function:%s>> ", __FILE__, __LINE__, __FUNCTION__);\
    printf(fmt, ##args);\
}while(0)
#define TElemType int
int top=-1;//top變量時刻表示棧頂元素所在位置
//構造結點的結構體
typedef struct BiTNode{
    //數據域
    TElemType data;
    //左右孩子指針
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
/**
 * @Description: 初始化樹
 * @Param: BiTree *T  結構體指針的指針
 * @Return: 無
 * @Author: Carlos
 */
void CreateBiTree(BiTree *T){
    *T=(BiTree)malloc(sizeof(BiTNode));
    (*T)->data=1;
    (*T)->lchild=(BiTree)malloc(sizeof(BiTNode));
    (*T)->rchild=(BiTree)malloc(sizeof(BiTNode));
    (*T)->lchild->data=2;
    (*T)->lchild->lchild=(BiTree)malloc(sizeof(BiTNode));
    (*T)->lchild->rchild=(BiTree)malloc(sizeof(BiTNode));
    (*T)->lchild->rchild->data=5;
    (*T)->lchild->rchild->lchild=NULL;
    (*T)->lchild->rchild->rchild=NULL;
    (*T)->rchild->data=3;
    (*T)->rchild->lchild=(BiTree)malloc(sizeof(BiTNode));
    (*T)->rchild->lchild->data=6;
    (*T)->rchild->lchild->lchild=NULL;
    (*T)->rchild->lchild->rchild=NULL;
    (*T)->rchild->rchild=(BiTree)malloc(sizeof(BiTNode));
    (*T)->rchild->rchild->data=7;
    (*T)->rchild->rchild->lchild=NULL;
    (*T)->rchild->rchild->rchild=NULL;
    (*T)->lchild->lchild->data=4;
    (*T)->lchild->lchild->lchild=NULL;
    (*T)->lchild->lchild->rchild=NULL;
}
/**
 * @Description: 中序遍歷使用的進棧函數
 * @Param: BiTree* a 指向樹的指針數組 BiTree elem 進棧的元素
 * @Return: 無
 * @Author: Carlos
 */
void Push(BiTree* a,BiTree elem){
    //指針進棧
    a[++top]=elem;
}
/**
 * @Description: 前序遍歷使用的彈棧函數
 * @Param: 無
 * @Return: 無
 * @Author: Carlos
 */
void Pop( ){
    if (top==-1) {
        return;
    }
    top--;
}
/**
 * @Description: 顯示函數
 * @Param: BiTree elem 指向樹的指針
 * @Return: 無
 * @Author: Carlos
 */
void PrintBiT(BiTree elem){
    printf("%d ",elem->data);
}
/**
 * @Description: 拿到棧頂元素
 * @Param: BiTree*a 指針數組
 * @Return: 棧頂元素的地址
 * @Author: Carlos
 */
BiTree GetTop(BiTree*a){
    return a[top];
}
/**
 * @Description: 中序遍歷非遞歸算法，先左，然後回退，然後右。從根結點開始，遍歷左孩子同時壓棧，當遍歷結束，說明當前遍歷的結點沒有左孩子，
 * 從棧中取出來調用操作函數，然後訪問該結點的右孩子，繼續以上重複性的操作
 * @Return: 棧頂元素的地址
 * @Author: Carlos
 */
void InOrderTraverse1(BiTree Tree){
    //定義一個順序棧
    BiTree a[20];
    //臨時指針
    BiTree p;
    //根結點進棧
    Push(a, Tree);
    //top!=-1說明棧內不爲空，程序繼續運行
    while (top!=-1) {
        //一直取棧頂元素，且不能爲NULL
        while ((p=GetTop(a)) &&p){
            //將該結點的左孩子進棧，如果沒有左孩子，NULL進棧
            Push(a, p->lchild);
        }
        //跳出循環，棧頂元素肯定爲NULL，將NULL彈棧。 打印的第一個元素沒有右孩子，所以也會Pop掉，再取棧頂元素就是第一個元素的父節點
        Pop();
        if (top!=-1) {
            //取棧頂元素
            p=GetTop(a);
            //棧頂元素彈棧
            Pop();
            //遍歷完所有左孩子之後，打印棧頂的元素。
            PrintBiT(p);
            //將p指向的結點的右孩子進棧
            Push(a, p->rchild);
        }
    }
}
/**
 * @Description: 中序遍歷非遞歸算法。中序遍歷過程中，只需將每個結點的左子樹壓棧即可，右子樹不需要壓棧。
 * 當結點的左子樹遍歷完成後，只需要以棧頂結點的右孩子爲根結點，繼續循環遍歷即可
 * @Param: 無
 * @Return: 棧頂元素的地址
 * @Author: Carlos
 */
void InOrderTraverse2(BiTree Tree){
    //定義一個順序棧
    BiTree a[20];
    //臨時指針
    BiTree p;
    p=Tree;
    //當p爲NULL或者棧爲空時，表明樹遍歷完成
    while (p || top!=-1) {
        //如果p不爲NULL，將其壓棧並遍歷其左子樹
        if (p) {
            Push(a, p);
            p=p->lchild;
        }
        //如果p==NULL，表明左子樹遍歷完成，需要遍歷上一層結點的右子樹  彈出時順便訪問右子樹
        else{
            p=GetTop(a);
            Pop();
            PrintBiT(p);
            p=p->rchild;
        }
    }
}
int main(){
    BiTree Tree;
    CreateBiTree(&Tree);
    printf("中序遍歷: \r\n");
    InOrderTraverse2(Tree);
    DBG_PRINTF("123456\r\n");
    return 0;
}

後序遍歷

後序遍歷規則

  二叉樹後序遍歷的實現思想是：1.訪問左子樹；2.訪問右子樹；3.完成該節點的左右子樹的訪問後，再訪問該節點。即考察到一個節點後，將其暫存，遍歷完左右子樹後，再輸出該節點的值。(左右根)

後序遍歷舉例

在這裏插入圖片描述
  如上圖中，對此二叉樹進行後序遍歷的操作過程爲：
  從根節點 1 開始，遍歷該節點的左子樹（以節點 2 爲根節點）；
  1.遍歷節點 2 的左子樹（以節點 4 爲根節點）；
  2.由於節點 4 既沒有左子樹，也沒有右子樹，此時訪問該節點中的元素 4，並回退到節點 2 ，遍歷節點 2 的右子樹（以 5 爲根節點）；
  3.由於節點 5 無左右子樹，因此可以訪問節點 5 ，並且此時節點 2 的左右子樹也遍歷完成，因此也可以訪問節點 2；
  4.此時回退到節點 1 ，開始遍歷節點 1 的右子樹（以節點 3 爲根節點）；
  5.遍歷節點 3 的左子樹（以節點 6 爲根節點）；
  6.由於節點 6 無左右子樹，因此訪問節點 6，並回退到節點 3，開始遍歷節點 3 的右子樹（以節點 7 爲根節點）；
  7.由於節點 7 無左右子樹，因此訪問節點 7，並且節點 3 的左右子樹也遍歷完成，可以訪問節點 3；節點 1 的左右子樹也遍歷完成，可以訪問節點 1；
  由此，對上圖 中二叉樹進行後序遍歷的結果爲：4 5 2 6 7 3 1

後序遍歷代碼（遞歸）

/*
 * @Description: 二叉樹的後序遍歷（遞歸）
 * @Version: V1.0
 * @Autor: Carlos
 * @Date: 2020-05-18 16:23:57
 * @LastEditors: Carlos
 * @LastEditTime: 2020-05-30 17:29:38
 */ 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define TElemType int
//構造結點的結構體
typedef struct BiTNode{
    //數據域
    TElemType data;
    //左右孩子指針
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
/**
* @Description: 初始化樹
* @Param: BiTree *T  結構體指針
* @Return: 無
* @Author: Carlos
*/
void CreateBiTree(BiTree *T){
    *T=(BiTree)malloc(sizeof(BiTNode));
    (*T)->data=1;
    (*T)->lchild=(BiTree)malloc(sizeof(BiTNode));
    (*T)->rchild=(BiTree)malloc(sizeof(BiTNode));
  
    (*T)->lchild->data=2;
    (*T)->lchild->lchild=(BiTree)malloc(sizeof(BiTNode));
    (*T)->lchild->rchild=(BiTree)malloc(sizeof(BiTNode));

    (*T)->lchild->rchild->data=5;
    (*T)->lchild->rchild->lchild=NULL;
    (*T)->lchild->rchild->rchild=NULL;

    (*T)->rchild->data=3;
    (*T)->rchild->lchild=(BiTree)malloc(sizeof(BiTNode));
    (*T)->rchild->lchild->data=6;
    (*T)->rchild->lchild->lchild=NULL;
    (*T)->rchild->lchild->rchild=NULL;

    (*T)->rchild->rchild=(BiTree)malloc(sizeof(BiTNode));
    (*T)->rchild->rchild->data=7;
    (*T)->rchild->rchild->lchild=NULL;
    (*T)->rchild->rchild->rchild=NULL;
    
    (*T)->lchild->lchild->data=4;
    (*T)->lchild->lchild->lchild=NULL;
    (*T)->lchild->lchild->rchild=NULL;
}

/**
* @Description: 顯示函數
* @Param: BiTree elem 指向樹的結構體指針
* @Return: 無
* @Author: Carlos
*/
void PrintBiT(BiTree elem){
    printf("%d ",elem->data);
}
/**
* @Description: 先序遍歷
* @Param: BiTree T 指針數組，存放各個節點的指針
* @Return: 無
* @Author: Carlos
*/
void PreOrderTraverse(BiTree T){
    if (T) {
        PreOrderTraverse(T->lchild);//訪問該結點的左孩子
        PreOrderTraverse(T->rchild);//訪問該結點的右孩子
         PrintBiT(T);//調用操作結點數據的函數方法
    }
    //如果結點爲空，返回上一層
    return;
}
int main() {
    BiTree Tree;
    CreateBiTree(&Tree);
    printf("後序遍歷: \n");
    PreOrderTraverse(Tree);
}

後序遍歷代碼（非遞歸）

/*
 * @Description: 二叉樹的後序遍歷（非遞歸）
 * @Version: V1.0
 * @Autor: Carlos
 * @Date: 2020-05-18 16:23:57
 * @LastEditors: Carlos
 * @LastEditTime: 2020-05-18 16:24:29
 */ 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define TElemType int
//top變量時刻表示棧頂元素所在位置
int top=-1;
//構造結點的結構體
typedef struct BiTNode{
    //數據域
    TElemType data;
    //左右孩子指針
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
/**
 * @Description: 初始化樹
 * @Param: BiTree *T  結構體指針數組
 * @Return: 無
 * @Author: Carlos
 */
void CreateBiTree(BiTree *T){
    *T=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->data=1;
    (*T)->lchild=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->rchild=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->lchild->data=2;
    (*T)->lchild->lchild=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->lchild->rchild=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->lchild->rchild->data=5;
    (*T)->lchild->rchild->lchild=NULL;
    (*T)->lchild->rchild->rchild=NULL;
    (*T)->rchild->data=3;
    (*T)->rchild->lchild=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->rchild->lchild->data=6;
    (*T)->rchild->lchild->lchild=NULL;
    (*T)->rchild->lchild->rchild=NULL;
    (*T)->rchild->rchild=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->rchild->rchild->data=7;
    (*T)->rchild->rchild->lchild=NULL;
    (*T)->rchild->rchild->rchild=NULL;
    (*T)->lchild->lchild->data=4;
    (*T)->lchild->lchild->lchild=NULL;
    (*T)->lchild->lchild->rchild=NULL;
}
/**
 * @Description: 後序遍歷使用的彈棧函數
 * @Param: 無
 * @Return: 無
 * @Author: Carlos
 */
void Pop( ){
    if (top==-1) {
        return ;
    }
    top--;
}
/**
 * @Description: 顯示函數
 * @Param: 無
 * @Return: 無
 * @Author: Carlos
 */
void PrintBiT(BiTree elem){
    printf("%d ",elem->data);
}

//增加左右子樹的訪問標誌
typedef struct SNode{
    BiTree p;
    int tag;
}SNode;
/**
 * @Description: 後序遍歷使用的進棧函數
 * @Param: SNode *a 指向樹和標誌位的結構體的指針 BiTree sdata 進棧的元素
 * @Return: 無
 * @Author: Carlos
 */
void Push(SNode *a,SNode sdata){
    a[++top]=sdata;
}
/**
 * @Description: 後序遍歷非遞歸算法。後序遍歷是在遍歷完當前結點的左右孩子之後，才調用操作函數，所以需要在操作結點進棧時，爲每個結點配備一個標誌位。
 * 當遍歷該結點的左孩子時，設置當前結點的標誌位爲 0，進棧；當要遍歷該結點的右孩子時，設置當前結點的標誌位爲 1，進棧。這樣，當遍歷完成，該結點彈棧時，
 * 查看該結點的標誌位的值：如果是 0，表示該結點的右孩子還沒有遍歷；反之如果是 1，說明該結點的左右孩子都遍歷完成，可以調用操作函數。
 * @Param: 結構體指針數組
 * @Return: 無
 * @Author: Carlos
 */
void PostOrderTraverse(BiTree Tree){
    //定義一個順序棧
    SNode a[20];
    //臨時指針
    BiTree p;
    int tag;
    SNode sdata;
    p=Tree;
    while (p||top!=-1) {
        //左孩子進棧
        while (p) {
            //爲該結點入棧做準備
            sdata.p=p;
            //由於遍歷是左孩子，設置標誌位爲0
            sdata.tag=0;
            //壓棧
            Push(a, sdata);
            //以該結點爲根結點，遍歷左孩子
            p=p->lchild;
        }
        //取棧頂元素 取左孩子的父節點
        sdata=a[top];
        //棧頂元素彈棧
        Pop();
        p=sdata.p;
        tag=sdata.tag;
        //右孩子進棧
        //如果tag==0，說明該結點還沒有遍歷它的右孩子
        if (tag==0) {
            sdata.p=p;
            sdata.tag=1;
            //更改該結點的標誌位，重新壓棧
            Push(a, sdata);
            //以該結點的右孩子爲根結點，重複循環
            p=p->rchild;
        }
        //如果取出來的棧頂元素的tag==1，說明此結點左右子樹都遍歷完了，可以調用操作函數了
        else{
            PrintBiT(p);
            p=NULL;
        }
    }
}
int main(){
    BiTree Tree;
    CreateBiTree(&Tree);
    printf("後序遍歷: \n");
    PostOrderTraverse(Tree);
}

層次遍歷

層次遍歷規則

  按照二叉樹中的層次從左到右依次遍歷每層中的結點。通過使用隊列的數據結構，從樹的根結點開始，依次將其左孩子和右孩子入隊。而後每次隊列中一個結點出隊，都將其左孩子和右孩子入隊，直到樹中所有結點都出隊，出隊結點的先後順序就是層次遍歷的最終結果。

層次遍歷舉例

在這裏插入圖片描述
  例如，層次遍歷如上圖中的二叉樹：
  1.根結點 1 入隊；
  2.根結點 1 出隊，出隊的同時，將左孩子 2 和右孩子 3 分別入隊；
  3.隊頭結點 2 出隊，出隊的同時，將結點 2 的左孩子 4 和右孩子 5 依次入隊；
  4.隊頭結點 3 出隊，出隊的同時，將結點 3 的左孩子 6 和右孩子 7 依次入隊；
  5.不斷地循環，直至隊列內爲空。

層次遍歷代碼

/*
 * @Description: 二叉樹的層次遍歷
 * @Version: V1.0
 * @Autor: Carlos
 * @Date: 2020-05-20 14:52:38
 * @LastEditors: Carlos
 * @LastEditTime: 2020-05-30 17:41:48
 */ 
#include <stdio.h>
#include <stdlib.h>
#define TElemType int
//初始化隊頭和隊尾指針開始時都爲0
int front=0,rear=0;
typedef struct BiTNode{
    //數據域
    TElemType data;
    //左右孩子指針
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
//採用順序隊列，初始化創建隊列數組
BiTree a[20];
/**
 * @Description: 初始化二叉樹
 * @Param: BiTree *T 二叉樹的結構體指針數組
 * @Return: 無
 * @Author: Carlos
 */
void CreateBiTree(BiTree *T){
    *T=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->data=1;
    (*T)->lchild=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->rchild=(BiTNode*)malloc(sizeof(BiTNode));
   
    (*T)->lchild->data=2;
    (*T)->lchild->lchild=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->lchild->rchild=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->lchild->rchild->data=5;
    (*T)->lchild->rchild->lchild=NULL;
    (*T)->lchild->rchild->rchild=NULL;
   
    (*T)->rchild->data=3;
    (*T)->rchild->lchild=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->rchild->lchild->data=6;
    (*T)->rchild->lchild->lchild=NULL;
    (*T)->rchild->lchild->rchild=NULL;
   
    (*T)->rchild->rchild=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->rchild->rchild->data=7;
    (*T)->rchild->rchild->lchild=NULL;
    (*T)->rchild->rchild->rchild=NULL;
   
    (*T)->lchild->lchild->data=4;
    (*T)->lchild->lchild->lchild=NULL;
    (*T)->lchild->lchild->rchild=NULL;
}
/**
 * @Description: 入隊
 * @Param: BiTree *a 二叉樹結構體指針  BiTree node 入隊的節點
 * @Return: 無
 * @Author: Carlos
 */
void EnQueue(BiTree *a,BiTree node){
    a[rear++]=node;
}
/**
 * @Description: 出隊
 * @Param: BiTree *node 二叉樹結構體指針數組
 * @Return: 結構體指針
 * @Author: Carlos
 */
BiTree DeQueue(BiTree *node){
    return a[front++];
}
/**
 * @Description: 二叉樹輸出函數
 * @Param: BiTree node 輸出的節點
 * @Return: 無
 * @Author: Carlos
 */
void displayNode(BiTree node){
    printf("%d ",node->data);
}
int main() {
    BiTree tree;
    //初始化二叉樹
    CreateBiTree(&tree);
    BiTree p;

    //根結點入隊
    EnQueue(a, tree);
    //當隊頭和隊尾相等時，表示隊列爲空
    while(front<rear) {
        //隊頭結點出隊
        p=DeQueue(a);
        displayNode(p);
        //將隊頭結點的左右孩子依次入隊
        if (p->lchild!=NULL) {
            EnQueue(a, p->lchild);
        }
        if (p->rchild!=NULL) {
            EnQueue(a, p->rchild);
        }
    }
    return 0;
}

  總結：其實不管是哪種遍歷方式，我們最終的目的就是訪問所有的樹（子樹）的根節點，左孩子，右孩子。那麼在訪問的過程中，肯定不能一次訪問並打印完畢。這個時候就需要棧來暫存我們已經訪問過的元素。在需要的時候將其打印出來即可。
  文中代碼均已測試，有任何意見或者建議均可聯繫我。歡迎學習交流！
  如果覺得寫的不錯，請點個贊再走，謝謝！

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

leetcode-112-路徑總和

function TreeNode(val) { this.val = val; this.left = this.right = null; } 解一：遞歸 先判斷樹結構是否爲null，如果是null，直接

叄贰壹 2020-07-08 12:04:52

【劍指offer】題61：二叉樹序列化、反序列化

使用stringstream http://blog.csdn.net/xw20084898/article/details/21939811 stringstream 是 C++ 提供的另一個字串型的串流(stream)

xiaxzhou 2020-07-08 11:22:52

【劍指offer】題60：分層遍歷打印二叉樹

void Print(TreeNode* pRoot) { queue<TreeNode*> que; int cur_count(0); int next_count(0); if (pRoo

xiaxzhou 2020-07-08 11:22:52

2015-11-2 【項目3 - 利用二叉樹遍歷思想解決問題】

1.問題及代碼 假設二叉樹採用二叉鏈存儲結構存儲，分別實現以下算法，並在程序中完成測試： 　　（1）計算二叉樹節點個數； 　　（2）輸出所有葉子節點； 　　（3）求二叉樹b的葉子節點個數； 　　（4）設計一個算法Level(b,x

SupreEvi 2020-07-08 11:14:27

帶路徑壓縮的並查集C/C++模板

拿下面一道入門並查集的題作爲例子 重點在於father數組、getFather函數、union函數 這篇博文的目的是記錄下並查集的模板！   題目背景 若某個家族人員過於龐大，要判斷兩個是否是親戚，確實還很不容易，現在給出某個親戚關係圖，

NGU_Jq 2020-07-08 10:21:35

用先序序列和中序序列創建二叉樹

題目描述 輸入格式 第一行： 樹的中序遍歷 第二行： 同樣的樹的前序遍歷 輸出格式 單獨的一行表示該樹的後序遍歷。 輸入輸出樣例 輸入 #1複製 ABEDFCHG CBADEFGH 輸出 #1複製 AEFDBHGC 模板如下：重在

NGU_Jq 2020-07-08 10:21:35

【算法】【遞歸篇】【樹】第8節：leetcode 102. 二叉樹的層序遍歷（BFS與DFS）

本期任務：介紹leetcode中樹的幾個經典問題的遞歸解法 【算法】【遞歸篇】【樹】第1節：leetcode 100. 相同的樹 【算法】【遞歸篇】【樹】第2節：leetcode 105. 從前序與中序遍歷序列構造二叉樹 【算法】

岚清子 2020-07-08 09:13:37

【算法】【遞歸篇】【樹】第6節：leetcode 101. 對稱二叉樹

本期任務：介紹leetcode中樹的幾個經典問題的遞歸解法 【算法】【遞歸篇】【樹】第1節：leetcode 100. 相同的樹 【算法】【遞歸篇】【樹】第2節：leetcode 105. 從前序與中序遍歷序列構造二叉樹 【算法】

岚清子 2020-07-08 09:13:35

【算法】【遞歸篇】【樹】第7節：leetcode 98. 驗證二叉搜索樹（神奇的中序遍歷！！！）

本期任務：介紹leetcode中樹的幾個經典問題的遞歸解法 【算法】【遞歸篇】【樹】第1節：leetcode 100. 相同的樹 【算法】【遞歸篇】【樹】第2節：leetcode 105. 從前序與中序遍歷序列構造二叉樹 【算法】

岚清子 2020-07-08 09:13:35

Leetcode226. 翻轉二叉樹

翻轉一棵二叉樹。 示例： 輸入： 4 / \ 2 7 / \ / \ 1 3 6 9 輸出： 4 / \ 7 2 / \ / \ 9 6

子奔奔超人 2020-07-08 05:24:24

【樹】A041_LC_監控二叉樹（後序遍歷）

一、Problem 給定一個二叉樹，我們在樹的節點上安裝攝像頭。 節點上的每個攝影頭都可以監視其父對象、自身及其直接子對象。 計算監控樹的所有節點所需的最小攝像頭數量。 輸入：[0,0,null,0,null,0,null,nu

ByteSinging 2020-07-08 05:01:10

【樹】B043_LC_在二叉樹中分配硬幣（後序遍歷）

一、Problem 給定一個有 N 個結點的二叉樹的根結點 root，樹中的每個結點上都對應有 node.val 枚硬幣，並且總共有 N 枚硬幣。 在一次移動中，我們可以選擇兩個相鄰的結點，然後將一枚硬幣從其中一個結點移動到另一個

ByteSinging 2020-07-08 05:01:10

遞歸之兔子問題

1.有一對兔子，從出生後第3個月起每個月都生一對兔子，小兔子長到第三個月後每個月又生一對兔子，假如兔子都不死，問第二十個月的兔子對數爲多少？ (使用遞歸去解決) 分析：首先我們要明白題目的意思指的是每個月的兔子總對數；假設將兔子分爲小中大

dreamer_96 2020-07-08 10:26:31

使用遞歸解決漢諾塔問題

  # 漢諾塔（又稱河內塔）問題是源於印度一個古老傳說的益智玩具。 # 大梵天創造世界的時候做了三根金剛石柱子，在一根柱子上從下往上按照大小順序摞着64片黃金圓盤。 # 大梵天命令婆羅門把圓盤從下面開始按大小順序重新擺放在另

YuJar 2020-07-08 10:22:34

使用遞歸實現全排列

重新看了回遞歸之後，順便寫了個使用遞歸實現全排列的算法，感覺空間複雜度有點大，等有時間再更改吧，發表出來，因爲算法功底實在有限，所以希望哪位可以幫忙優化優化，本人將感激不盡！ 算法是這樣的，如果給定N個不同字符，將這N個字符全排列，最終的

KeepThinking_ 2020-07-08 05:35:39