二叉树的遍历

已于 2024-07-29 18:36:28 修改
阅读量359 收藏 9
点赞数 8
分类专栏： 数据结构 文章标签： 算法
于 2024-07-26 21:44:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65866298/article/details/140724347
版权

目录

1.先序

        1.1递归形式

        1.2非递归形式

2.中序

        2.1递归形式

        2.2非递归形式

3.后序

        3.1递归形式

        3.2非递归形式

4.层序

        4.1层序遍历的核心问题 

        4.1队列实现 

 5.二叉树及其遍历C语言实现

6.二叉树遍历的总结 

提纲挈领的说，先序中序后序的遍历区别在于遍历根节点的时机。 

1.先序

        1.1递归形式

 遍历过程为：

① 访问根结点； ② 先序遍历其左子树； ③ 先序遍历其右子树。

void PreOrderTraversal( BinTree BT )
{
    if( BT ) {
     printf(“%d”, BT->Data);
     PreOrderTraversal( BT->Left );
     PreOrderTraversal( BT->Right );
    }
}

        1.2非递归形式

使用一个栈，按照根节点、右子树、左子树的顺序入栈。 

void PreOrderTraversal(BinTree BT) {
    if (BT == NULL) return;

    Stack S = CreatStack(100); /* 示例最大大小，根据需要调整 */
    Push(&S, BT);

    while (!IsEmpty(S)) {
        BinTree T = Pop(&S);
        printf("%5d ", T->Data);
        
        if (T->Right) Push(&S, T->Right);  // 右子节点先入栈
        if (T->Left) Push(&S, T->Left);    // 左子节点后入栈
    }
}

2.中序

        2.1递归形式

遍历过程为： ① 中序遍历其左子树； ② 访问根结点； ③ 中序遍历其右子树。 

void InOrderTraversal( BinTree BT )
{
 if( BT ) {
     InOrderTraversal( BT->Left );
     printf(“%d”, BT->Data);
     InOrderTraversal( BT->Right );
 }
}

        2.2非递归形式

中序遍历的顺序是：左子树 -> 根节点 -> 右子树。使用栈的方式进行遍历时，通常先遍历左子树直到没有左子节点，然后访问根节点，最后遍历右子树。 

中序遍历非递归遍历算法【使用堆栈】

 遇到一个结点，就把它压栈，并去遍历它的左子树；

 当左子树遍历结束后，从栈顶弹出这个结点并访问它；

 然后按其右指针再去中序遍历该结点的右子树。 

void InOrderTraversal( BinTree BT )
{ 
    BinTree T=BT;
    Stack S = CreatStack( MaxSize ); /*创建并初始化堆栈S*/
    while( T || !IsEmpty(S) ){
         while(T){ /*一直向左并将沿途结点压入堆栈*/
             Push(S,T);
             T = T->Left;
         }
         if(!IsEmpty(S)){
             T = Pop(S); /*结点弹出堆栈*/
             printf(“%5d”, T->Data); /*（访问）打印结点*/
             T = T->Right; /*转向右子树*/
         }
    }
}

3.后序

        3.1递归形式

 遍历过程为： ① 后序遍历其左子树； ② 后序遍历其右子树； ③ 访问根结点。

void PostOrderTraversal( BinTree BT )
{
 if( BT ) {
     PostOrderTraversal( BT->Left );
     PostOrderTraversal( BT->Right);
     printf(“%d”, BT->Data);
 }
}

        3.2非递归形式

        使用两个栈，第一个栈用于存储节点，第二个栈用于存储遍历结果，最后反向打印第二个栈的内容。

void PostOrderTraversal(BinTree BT) {
    if (BT == NULL) return;

    Stack S1 = CreatStack(100);  // 用于保存节点
    Stack S2 = CreatStack(100);  // 用于保存遍历结果

    Push(&S1, BT);

    while (!IsEmpty(S1)) {
        BinTree T = Pop(&S1);
        Push(&S2, T);  // 将节点压入S2

        if (T->Left) Push(&S1, T->Left);
        if (T->Right) Push(&S1, T->Right);
    }

    // 打印结果栈中的节点数据，顺序为后序遍历结果
    while (!IsEmpty(S2)) {
        BinTree T = Pop(&S2);
        printf("%5d ", T->Data);
    }
}

4.层序

        4.1层序遍历的核心问题 

我们需要从上到下，从左至右依次输出每个结点，这相当于“二维结构的线性化”

 从结点访问其左、右儿子结点

 访问左儿子后，右儿子结点怎么办？

 需要一个存储结构保存暂时不访问的结点

 存储结构：堆栈、队列 

        4.1队列实现 

         遍历从根结点开始，首先将根结点入队，然后开始执行循环：结点出队、访问该结点、其左右儿子入队。

层序基本过程：

 先根结点入队，然后：

 从队列中取出一个元素；

 访问该元素所指结点；

 若该元素所指结点的左、右孩子结点非空， 则将其左、右孩子的指针顺序入队。 

void LevelOrderTraversal ( BinTree BT )
{ 
    Queue Q; 
    BinTree T;
    if ( !BT ) return; /* 若是空树则直接返回 */
    Q = CreatQueue( MaxSize ); /*创建并初始化队列Q*/
    AddQ( Q, BT );
    while ( !IsEmptyQ( Q ) ) {
         T = DeleteQ( Q );
         printf(“%d\n”, T->Data); /*访问取出队列的结点*/
         if ( T->Left ) AddQ( Q, T->Left );
         if ( T->Right ) AddQ( Q, T->Right );
    }
}

 5.二叉树及其遍历C语言实现

二叉树示例

代码示例

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

// 定义学生信息结构体
typedef struct student {
    char num[50];   // 学号
    char name[50];  // 姓名
    char sex[10];   // 性别
    int age;        // 年龄
} ElementType;

typedef struct TreeNode *BinTree;
typedef BinTree Position;

struct TreeNode {
    ElementType Data;
    BinTree Left;
    BinTree Right;
};

// 栈结构体及相关操作函数的声明
typedef struct StackNode *Stack;
Stack CreateStack(int MaxSize);
void Push(Stack S, BinTree BT);
BinTree Pop(Stack S);
int IsEmpty(Stack S);

// 队列结构体及相关操作函数的声明
typedef struct QueueNode *Queue;
Queue CreateQueue(int MaxSize);
void AddQ(Queue Q, BinTree BT);
BinTree DeleteQ(Queue Q);
int IsEmptyQ(Queue Q);

// 递归先序遍历
void PreOrderTraversalRecursive(BinTree BT) {
    if (BT) {
        printf("%s ", BT->Data.num);
        PreOrderTraversalRecursive(BT->Left);
        PreOrderTraversalRecursive(BT->Right);
    }
}

// 非递归先序遍历
void PreOrderTraversal(BinTree BT) {
    if (BT == NULL) return;

    Stack S = CreateStack(100); /* 示例最大大小，根据需要调整 */
    Push(S, BT);

    while (!IsEmpty(S)) {
        BinTree T = Pop(S);
        printf("%s ", T->Data.num);

        if (T->Right) Push(S, T->Right);  // 右子节点先入栈
        if (T->Left) Push(S, T->Left);    // 左子节点后入栈
    }
}

// 递归中序遍历
void InOrderTraversalRecursive(BinTree BT) {
    if (BT) {
        InOrderTraversalRecursive(BT->Left);
        printf("%s ", BT->Data.num);
        InOrderTraversalRecursive(BT->Right);
    }
}

// 非递归中序遍历
void InOrderTraversal(BinTree BT) {
    BinTree T = BT;
    Stack S = CreateStack(100); /* 示例最大大小，根据需要调整 */
    while (T || !IsEmpty(S)) {
        while (T) { /* 一直向左并将沿途结点压入堆栈 */
            Push(S, T);
            T = T->Left;
        }
        if (!IsEmpty(S)) {
            T = Pop(S); /* 结点弹出堆栈 */
            printf("%s ", T->Data.num); /* （访问）打印结点 */
            T = T->Right; /* 转向右子树 */
        }
    }
}

// 递归后序遍历
void PostOrderTraversalRecursive(BinTree BT) {
    if (BT) {
        PostOrderTraversalRecursive(BT->Left);
        PostOrderTraversalRecursive(BT->Right);
        printf("%s ", BT->Data.num);
    }
}

// 非递归后序遍历
void PostOrderTraversal(BinTree BT) {
    if (BT == NULL) return;

    Stack S1 = CreateStack(100);  // 用于保存节点
    Stack S2 = CreateStack(100);  // 用于保存遍历结果

    Push(S1, BT);

    while (!IsEmpty(S1)) {
        BinTree T = Pop(S1);
        Push(S2, T);  // 将节点压入S2

        if (T->Left) Push(S1, T->Left);
        if (T->Right) Push(S1, T->Right);
    }

    // 打印结果栈中的节点数据，顺序为后序遍历结果
    while (!IsEmpty(S2)) {
        BinTree T = Pop(S2);
        printf("%s ", T->Data.num);
    }
}

// 层序遍历
void LevelOrderTraversal(BinTree BT) {
    if (BT == NULL) return;

    Queue Q = CreateQueue(100); /* 创建并初始化队列 */
    AddQ(Q, BT);
    while (!IsEmptyQ(Q)) {
        BinTree T = DeleteQ(Q);
        printf("%s ", T->Data.num); /* 访问取出队列的结点 */
        if (T->Left) AddQ(Q, T->Left);
        if (T->Right) AddQ(Q, T->Right);
    }
}

// 栈和队列相关函数的占位符实现
struct StackNode {
    BinTree *Data;
    int Top;
    int MaxSize;
};

struct QueueNode {
    BinTree *Data;
    int Front, Rear;
    int MaxSize;
};

Stack CreateStack(int MaxSize) {
    Stack S = (Stack)malloc(sizeof(struct StackNode));
    S->Data = (BinTree *)malloc(MaxSize * sizeof(BinTree));
    S->Top = -1;
    S->MaxSize = MaxSize;
    return S;
}

void Push(Stack S, BinTree BT) {
    if (S->Top < S->MaxSize - 1) {
        S->Data[++S->Top] = BT;
    } else {
        printf("Stack Full\n");
    }
}

BinTree Pop(Stack S) {
    if (S->Top > -1) {
        return S->Data[S->Top--];
    } else {
        printf("Stack Empty\n");
        return NULL;
    }
}

int IsEmpty(Stack S) {
    return S->Top == -1;
}

Queue CreateQueue(int MaxSize) {
    Queue Q = (Queue)malloc(sizeof(struct QueueNode));
    Q->Data = (BinTree *)malloc(MaxSize * sizeof(BinTree));
    Q->Front = Q->Rear = 0;
    Q->MaxSize = MaxSize;
    return Q;
}

void AddQ(Queue Q, BinTree BT) {
    if ((Q->Rear + 1) % Q->MaxSize != Q->Front) {
        Q->Data[Q->Rear] = BT;
        Q->Rear = (Q->Rear + 1) % Q->MaxSize;
    } else {
        printf("Queue Full\n");
    }
}

BinTree DeleteQ(Queue Q) {
    if (Q->Front != Q->Rear) {
        BinTree BT = Q->Data[Q->Front];
        Q->Front = (Q->Front + 1) % Q->MaxSize;
        return BT;
    } else {
        printf("Queue Empty\n");
        return NULL;
    }
}

int IsEmptyQ(Queue Q) {
    return Q->Front == Q->Rear;
}

// 创建一个简单的二叉树用于测试
BinTree CreateSampleTree() {
    BinTree node1 = (BinTree)malloc(sizeof(struct TreeNode));
    BinTree node2 = (BinTree)malloc(sizeof(struct TreeNode));
    BinTree node3 = (BinTree)malloc(sizeof(struct TreeNode));
    BinTree node4 = (BinTree)malloc(sizeof(struct TreeNode));
    BinTree node5 = (BinTree)malloc(sizeof(struct TreeNode));

    strcpy(node1->Data.num, "1");
    strcpy(node2->Data.num, "2");
    strcpy(node3->Data.num, "3");
    strcpy(node4->Data.num, "4");
    strcpy(node5->Data.num, "5");

    node1->Left = node2;
    node1->Right = node3;
    node2->Left = node4;
    node2->Right = node5;
    node3->Left = node3->Right = NULL;
    node4->Left = node4->Right = NULL;
    node5->Left = node5->Right = NULL;

    return node1;
}

int main() {
    // 创建一个样例二叉树
    BinTree root = CreateSampleTree();

    // 测试递归先序遍历
    printf("递归先序遍历: ");
    PreOrderTraversalRecursive(root);
    printf("\n");

    // 测试非递归先序遍历
    printf("非递归先序遍历: ");
    PreOrderTraversal(root);
    printf("\n");

    // 测试递归中序遍历
    printf("递归中序遍历: ");
    InOrderTraversalRecursive(root);
    printf("\n");

    // 测试非递归中序遍历
    printf("非递归中序遍历: ");
    InOrderTraversal(root);
    printf("\n");

    // 测试递归后序遍历
    printf("递归后序遍历: ");
    PostOrderTraversalRecursive(root);
    printf("\n");

    // 测试非递归后序遍历
    printf("非递归后序遍历: ");
    PostOrderTraversal(root);
    printf("\n");

    // 测试层序遍历
    printf("层序遍历: ");
    LevelOrderTraversal(root);
    printf("\n");

    return 0;
}

程序运行结果： 

 

6.二叉树遍历的总结 

先序、中序和后序遍历过程：遍历过程中经过结点的路线一 样，只是访问各结点的时机不同。

 图中在从入口到出口的曲线上用⊗，☆和△三种符号分别标 记出了先序、中序和后序访问各结点的时刻

 

码明
关注
  • 8
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树遍历小结
u013146060的博客
12-28 1532
二叉树是相当重要的数据结构，目前我还只会玩玩它的遍历（年轻不懂事没好好学，不然早就达到人生巅峰了），leetcode上二叉树的简单题，大部分通过遍历加一点逻辑即可解决，所以总结一下几种遍历方法（其实也是看题解白嫖的）。二叉树遍历有广度优先，深度优先两种方式，深度优先又分先序遍历（根，左，右），中序遍历（左，根，右），后序便利(左，右，根)，如果是二叉搜索树，中序遍历就是有序的了。广度优先方式没太多说，只能借助队列实现，而广度优先，可通过递归方式，借助栈迭代方式，递归方式在数据量大的情况下，可能导致栈溢出，栈
易语言二叉树遍历
07-21
二叉树遍历是理解数据结构和算法的基础，它包括前序遍历、中序遍历和后序遍历三种主要方法。 1. **二叉树的基本概念**： - 二叉树是一种特殊的树结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。 -...
二叉树遍历方法——前、中、后序遍历（java）
loss_rose777的博客
06-26 4万+
前序遍历是一种访问二叉树的每一个结点的方法，它的遍历顺序是根节点，左子树，右子树。
二叉树遍历方法——前、中、后序遍历（图解）
热门推荐
在夜里行走的博客
11-04 14万+
二叉树的前、中、后序遍历的递归与非递归算法
二叉树遍历顺序
weixin_49725030的博客
07-12 776
二叉树的遍历方式有三种：先序遍历、中序遍历和后序遍历 等。
一文搞懂二叉树遍历---超详解（二叉树逐步剖析二）
weixin_64067830的博客
04-27 5万+
二叉树遍历一文搞懂，快过来看看吧
二叉树遍历详解
码农笔记
01-16 5155
二叉树的遍历方式是最基本，也是最重要的一类题目，我们将从「前序」、「中序」、「后序」、「层序」四种遍历方式出发，总结他们的递归和迭代解法。 一、二叉树定义 二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个结点最多只能有两棵子树，且有左右之分。简单来说，就是一个包含节点，以及它的左右孩子的一种数据结构 假设二叉树的节...
java中的二叉树遍历
sutingStart的博客
01-27 1140
抛出几个问题java中什么是二叉树？在java中怎么体现？怎么进行增删改查？
数据结构--二叉树遍历(详细过程)
m0_56283131的博客
04-21 3万+
详细到啰嗦的程度，完全0基础都可完成。
二叉树遍历的非递归算法
m0_63223213的博客
08-05 1万+
非递归的算法主要采用的是循环出栈入栈来实现对二叉树的遍历，下面是过程分析
【C语言二叉树遍历实例】C语言二叉树遍历实例
05-20
二叉树的遍历C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历...
matlab实现二叉树遍历算法（源代码）
04-30
### MATLAB 实现二叉树遍历算法的知识点详解 #### 一、二叉树节点结构体定义 在MATLAB中实现二叉树的第一步是定义一个表示二叉树节点的结构体。在这个例子中，作者定义了一个名为`TreeNode`的类来表示节点，该类...
二叉树遍历流程图（先序、中序、后序、宽度遍历）
05-01
二叉树遍历是计算机科学中处理树结构数据时常用的一种技术，主要分为四种类型：先序遍历、中序遍历、后序遍历和宽度优先遍历。这些遍历方法各有特点，适用于不同的场景。 1. **先序遍历**： - **递归实现**：先...
二叉树遍历问题二叉树遍历问题
10-20
二叉树遍历是计算机科学中处理树结构数据时的一项基本操作，主要应用于数据的检索、存储和操作。在二叉树中，每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树遍历有四种常见的方法：先序遍历、中序...
Leetcode42接雨水（单调栈）
AGNING的博客
08-28 465
维护一个栈，满足从栈底到栈顶元素大小递减。如果当前元素高于栈顶，且栈内有至少2个元素，则形成了一个凹槽，及一个图中横着的红色矩形，将它的面积累加即可，第一次写难在维护单调栈中计算面积和。求出前缀最大和后缀最大，用两者较小值减去当前高度，累加即可，这个思路容易想到，这里不赘述。
算法的学习笔记—连续子数组的最大和
业精于勤，荒于嬉
08-29 3706
通过上述的动态规划方法，我们能够有效地解决连续子数组的最大和问题。该方法简单易懂，并且具有较高的效率，适合在大多数情况下使用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论😁如果帮助到您不妨3连支持一下，创造不易您们的支持是我的动力🤞。
【算法】C++贪心算法解题（单调递增数字、坏了的计算器、合并区间）
卜及中的博客
09-03 392
【算法】贪心算法解析：基本概念、策略证明与代码例题演示。
LeetCode LCR088.使用最小花费爬楼梯
最新发布
m0_63816268的博客
09-03 683
动态规划
递归、搜索与回溯算法
无聊_人的博客
08-29 7807
所谓的递归其实就是函数自己调用自己的情况。
二叉树遍历
06-01
二叉树遍历主要有三种方式：前序遍历、中序遍历和后序遍历。具体实现如下： 1. 前序遍历：先访问根节点，然后遍历左子树，最后遍历右子树。 ``` void preorderTraversal(TreeNode* root) { if (root == nullptr) ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值