二叉树--递归遍历--层次遍历--非递归遍历--详解

最新推荐文章于 2024-09-04 21:39:45 发布
最新推荐文章于 2024-09-04 21:39:45 发布
阅读量847 收藏 14
点赞数 25
文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zrk8008/article/details/141750777
版权


//数据结构--树-------------------------------------------------------------------------
// 树是一个n个结点的有限集，n为0时，为空树
// 1.树的定义是递归的，即定义中用到了自身
// 2.树的根节点没有前驱，其他所有结点有且只有一个前驱
// 3.树中的所有结点有0个或者多个后驱
//二叉树--------------------------------------------------
// 1.一种特殊的数据结构
// 2.每个结点只有两个子树
// 遍历方式：
// 根节点的遍历顺序 前 中 后
// 前序 根->左->右
// 中序 左->根->右
// 后序 左->右->根
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
创建一个结点
typedef struct TreeNode
{
    char data;
    struct TreeNode* Lchild;//左子串
    struct TreeNode* Rchild;//右子串
}TreeNode;
//创建二叉树--先序
void createTree(TreeNode** T,int *index)
//要改变树中的内容，需要传二级指针,
//data --数据  index--索引
{
    //获取一个数据
    char ch;
    scanf("%c", &ch);
    *index += 1;//计数，计算data的长度
    //如果输入的是# 则为空结点
    if (ch == '#')
    {
        *T = NULL;
    }
    //不是空结点
    else
    {
        //给T开辟空间
        *T = (TreeNode*)malloc(sizeof(TreeNode));
        //给data赋值
        (*T)->data = ch;
        //创建两个子树.引用创建树的函数本身，逻辑一致，进行递归
        //左子树
        createTree(&((*T)->Lchild),index);
        //右子树
        createTree(&((*T)->Rchild),index);
    }
}
//前序遍历
void preOrder(TreeNode* T)
{
    //如果为空
    if (T == NULL)
    { 
        return;
    }
    else
    {
        //先输出根数据
        printf("%c ", T->data);
        //输出左子树
        preOrder(T->Lchild);
        //输出右子树
        preOrder(T->Rchild);
    }
}
//中序遍历
void inOrder(TreeNode* T)
{
    //如果为空
    if (T == NULL)
    {
        return;
    }
    else
    {
        //输出左子树
        inOrder(T->Lchild);
        //输出根数据
        printf("%c ", T->data);
        //输出右子树
        inOrder(T->Rchild);
    }

}
//后序遍历
void postOrder(TreeNode* T)
{
    //如果为空
    if (T == NULL)
    {
        return;
    }
    else
    {
        //输出左子树
        postOrder(T->Lchild);
        //输出右子树
        postOrder(T->Rchild);
        //输出根数据
        printf("%c ", T->data);
    }
}
int main()
{
    TreeNode* T;
    int index = 0;
    createTree(&T, &index);
    preOrder(T);
    printf("\n");
    inOrder(T);
    printf("\n");
    postOrder(T);
    return 0;
}
//二叉树层次遍历--------------------------------------------------
// 按层遍历：利用队列先进先出原则，一层一层出栈
//创建一个树结点
typedef struct TreeNode
{
    char data;
    struct TreeNode* Lchild;//左子串
    struct TreeNode* Rchild;//右子串
}TreeNode;
//创建一个链式队列结点
typedef struct QueNode
{
    TreeNode* data;
    struct QueNode* prev;
    struct QueNode* next;
}QueNode;
//创建一个树
void createTree(TreeNode** T,int *index)
//要改变树中的内容，需要传二级指针,
//data --数据  index--索引
{
    //获取一个数据
    char ch;
    scanf("%c", &ch);
    *index += 1;//计数，计算data的长度
    //如果输入的是# 则为空结点
    if (ch == '#')
    {
        *T = NULL;
    }
    //不是空结点
    else
    {
        //给T开辟空间
        *T = (TreeNode*)malloc(sizeof(TreeNode));
        //给data赋值
        (*T)->data = ch;
        //创建两个子树.引用创建树的函数本身，逻辑一致，进行递归
        //左子树
        createTree(&((*T)->Lchild),index);
        //右子树
        createTree(&((*T)->Rchild),index);
    }
}
前序遍历检查
void preOrder(TreeNode* T)
{
    //如果为空
    if (T == NULL)
    { 
        return;
    }
    else
    {
        //先输出根数据
        printf("%c ", T->data);
        //输出左子树
        preOrder(T->Lchild);
        //输出右子树
        preOrder(T->Rchild);
    }
}
//建立队列头结点--使用双头循环链表
QueNode* InitQueue()
{
    QueNode* Q = (QueNode*)malloc(sizeof(QueNode));
    Q->data = NULL;
    Q->prev = Q;
    Q->next = Q;

    return Q;
}
//入队
void EnQueue(QueNode* Q,TreeNode* data)
{
    //创建一个队员结点
    QueNode* node = (QueNode*)malloc(sizeof(QueNode));
    //data赋值
    node->data = data;
    //尾插
    //prev指向队尾成员
    node->prev = Q->prev;
    //next指向头结点
    node->next = Q;
    //头结点指向的队尾成员的next指向node
    Q->prev->next = node;
    //头结点的prev指向node，成为新的队尾
    Q ->prev = node;
}
//判断是否为空
int IsEmpty(QueNode* Q)
{
    return Q->next == Q;//为空返回true，不为空返回false
}
//出队
QueNode* DeQueue(QueNode* Q)
{
    assert(!IsEmpty(Q));//断言是否为空
    //不为空
    //出队
    QueNode* Qnode = Q->next;//记录队头出队的结点
    Q->next = Qnode->next;//头结点指向出队数据的下一个结点
    Qnode->next->prev = Q;//出队数据的下一个结点的prev指向头结点
    //返回node
    return Qnode;
}
//层次遍历
void levelTraverse(QueNode* Q, TreeNode* T)
{
    //根节点入队
    EnQueue(Q, T);
    //不为空,按层次遍历访问，直到队列为空
    while (!IsEmpty(Q))
    {
        //出队
        QueNode* Qnode = DeQueue(Q);
        //打印指向树结点的数据
        printf("%c ", Qnode->data->data);
        //如果入队的根结点的左子树不为空,继续入队
        if (Qnode->data->Lchild)
        {
            EnQueue(Q, Qnode->data->Lchild);
        }
        //如果入队的根结点的右子树不为空,继续入队
        if (Qnode->data->Rchild)
        {
            EnQueue(Q, Qnode->data->Rchild);
        }
    }
    printf("\n");
}
int main()
{
    TreeNode* T;
    int index = 0;
    QueNode* Q = InitQueue();
    createTree(&T, &index);
    preOrder(T);
    levelTraverse(Q, T);

    return 0;
}
//二叉树非递归遍历---------------------------------------------------------------------
//利用栈的后进先出规则
// 前序
// 1.先访问，再入栈
// 2.循环，直到左子树为NULL
// 3.出栈，访问结点，入栈右子树
//
// 中序
// 1.先入栈
// 2.循环，直到左子树为NULL
// 3.出栈，再访问结点，入栈右子树
// 
// 后续
// 1.先入栈
// 2.循环，直到左子树为NULL
// 3.判断此时右子树是否为空，且是否被访问过，不为空且未被访问过则入栈
// 4.当左右子树为空时，则出栈，进行访问
// 
// 层层退出
//创建树的结点
typedef struct TreeNode
{
    char data;
    struct TreeNode* Lchild;
    struct TreeNode* Rchild;
}TreeNode;
//创建栈
typedef struct StackNode
{
    TreeNode* data;
    struct StackNode* next;
}StackNode;
//创建一个树
void createTree(TreeNode** T, int* index)
//要改变树中的内容，需要传二级指针,
//data --数据  index--索引
{
    //获取一个数据
    char ch;
    scanf("%c", &ch);
    *index += 1;//计数，计算data的长度
    //如果输入的是# 则为空结点
    if (ch == '#')
    {
        *T = NULL;
    }
    //不是空结点
    else
    {
        //给T开辟空间
        *T = (TreeNode*)malloc(sizeof(TreeNode));
        //给data赋值
        (*T)->data = ch;
        //创建两个子树.引用创建树的函数本身，逻辑一致，进行递归
        //左子树
        createTree(&((*T)->Lchild), index);
        //右子树
        createTree(&((*T)->Rchild), index);
    }
}
//初始化栈
StackNode* InitStack()
{
    StackNode* S = (StackNode*)malloc(sizeof(StackNode));
    S->data = NULL;
    S->next = NULL;
    return S;
}
//入栈
void PushStack(StackNode* S, TreeNode* data)
{
    //创建一个栈的新结点
    StackNode* node = (StackNode*)malloc(sizeof(StackNode));
    //赋值
    node->data = data;
    //头插
    //新节点的next指向->头结点指向的下一个结点
    node->next = S->next;
    //头结点指向新节点
    S->next = node;
}
//判断栈是否为空
int IsEmpty(StackNode* S)
{
    //为空返回真，不为空返回假
    return S->next == NULL;
}
//出栈
StackNode* PopStack(StackNode* S)
{
    //如果栈为空
    if (IsEmpty(S))
    {
        return NULL;
    }
    else
    {
        //出栈
        StackNode* node = S->next;
        //头结点指向下一个结点
        S->next = node->next;
        //返回Node
        return node;
    }
}
//递归遍历检查
void preOrder(TreeNode* T)
{
    //如果为空
    if (T == NULL)
    {
        return;
    }
    else
    {
        //先输出根数据
        printf("%c ", T->data);
        //输出左子树
        preOrder(T->Lchild);
        //输出右子树
        preOrder(T->Rchild);
    }
}
//非递归前序遍历
void PreOrder(TreeNode* T)
{
    //创建变量接收T
    TreeNode* node = T;
    //创建一个栈
    StackNode* S = InitStack();
    //当node不为空，或者栈不为空，执行循环
    while (node || !IsEmpty(S))
    {
        //树结点不为空
        if (node)
        {
            //先访问
            printf("%c ", node->data);
            //入栈
            PushStack(S, node);
            //node往后从左子树迭代，进入深层，直到左子树为空
            node = node->Lchild;
        }
        //左子树为空
        else
        {
            //出栈,用node记录出栈树结点
            node = PopStack(S)->data;
            //node迭代到出栈树节点的右子树，不为空就可入栈，为空则继续出栈
            //将node指向上一层的结点，便可继续遍历右子树，层层退出来
            node = node->Rchild;
        }
    }
}
//非递归中序遍历
void InOrder(TreeNode* T)
{
    //创建变量接收T
    TreeNode* node = T;
    //创建一个栈
    StackNode* S = InitStack();
    //当node不为空，或者栈不为空，执行循环
    while (node || !IsEmpty(S))
    {
        //树结点不为空
        if (node)
        {
            //先入栈
            PushStack(S, node);
            //node往后从左子树迭代，进入深层，直到左子树为空
            node = node->Lchild;
        }
        //左子树为空
        else
        {
            //出栈,用node记录出栈树结点
            node = PopStack(S)->data;
            //出栈后再访问
            printf("%c ", node->data);
            //node迭代到出栈树节点的右子树，不为空就可入栈，为空则继续出栈
            //将node指向上一层的结点，访问后，便可继续遍历右子树，层层退出来
            node = node->Rchild;
        }
    }
}
//非递归后序遍历
typedef struct TreeNode
{
    char data;
    struct TreeNode* Lchild;
    struct TreeNode* Rchild;
    int flag;//后序中需要判断右子树是否为空，且是否被访问过，做一个标识，如果访问过为1
    //没有访问过需要入栈
}TreeNode;
//创建栈
typedef struct StackNode
{
    TreeNode* data;
    struct StackNode* next;
}StackNode;
//创建一个树
void createTree(TreeNode** T, int* index)
//要改变树中的内容，需要传二级指针,
//data --数据  index--索引
{
    //获取一个数据
    char ch;
    scanf("%c", &ch);
    *index += 1;//计数，计算data的长度
    //如果输入的是# 则为空结点
    if (ch == '#')
    {
        *T = NULL;
    }
    //不是空结点
    else
    {
        //给T开辟空间
        *T = (TreeNode*)malloc(sizeof(TreeNode));
        //给data赋值
        (*T)->data = ch;
        //
        (*T)->flag = 0;

        //创建两个子树.引用创建树的函数本身，逻辑一致，进行递归
        //左子树
        createTree(&((*T)->Lchild), index);
        //右子树
        createTree(&((*T)->Rchild), index);
    }
}
//初始化栈
StackNode* InitStack()
{
    StackNode* S = (StackNode*)malloc(sizeof(StackNode));
    S->data = NULL;
    S->next = NULL;
    return S;
}
//入栈
void PushStack(StackNode* S, TreeNode* data)
{
    //创建一个栈的新结点
    StackNode* node = (StackNode*)malloc(sizeof(StackNode));
    //赋值
    node->data = data;
    //头插
    //新节点的next指向->头结点指向的下一个结点
    node->next = S->next;
    //头结点指向新节点
    S->next = node;
}
//判断栈是否为空
int IsEmpty(StackNode* S)
{
    //为空返回真，不为空返回假
    return S->next == NULL;
}
//出栈
StackNode* PopStack(StackNode* S)
{
    //如果栈为空
    if (IsEmpty(S))
    {
        return NULL;
    }
    else
    {
        //出栈
        StackNode* node = S->next;
        //头结点指向下一个结点
        S->next = node->next;
        //返回Node
        return node;
    }
}
//获取栈顶数据
StackNode* GetTop(StackNode* S)
{
    if (IsEmpty(S))
    {
        return NULL;
    }
    else
    {
        //取值
        StackNode* node = S->next;
        //返回
        return node;
    }
}
//非递归后续遍历
void PostOrder(TreeNode*T)
{
    //创建变量接收T
    TreeNode* node = T;
    //创建栈
    StackNode* S = InitStack();
    //当node不为空，或者栈不为空，执行循环
    while(node|| !IsEmpty(S))
    {
        if (node)
        {
            //入栈
            PushStack(S, node);
            //node往后迭代,左子树入栈，直到node为NULL；
            node = node->Lchild;
        }
        //当左子树为空
        else
        {
            //获取栈顶数据
            TreeNode* top = GetTop(S)->data;
            //如果栈顶数据的右子树不为空，且未被访问过
            if (top->Rchild && top->Rchild->flag == 0)
            {
                //将top指向右子树
                top = top->Rchild;
                //入栈右子树
                PushStack(S, top);
                //node往后迭代，直到左子树为NULL
                node = top->Lchild;
            }
            //右子树为空，此时左右子树皆为NULL
            else
            {
                //出栈
                top = PopStack(S)->data;
                //访问
                printf("%c ", top->data);
                //标识被访问过
                top->flag = 1;
            }
        }
    }
}

int main()
{
    TreeNode* T;
    int index = 0;
    createTree(&T,&index);
    /*preOrder(T);
    printf("\n");
    PreOrder(T);
    printf("\n");
    InOrder(T);
    printf("\n");*/
    PostOrder(T);
    return 0;
}

从菜鸟到小蠕虫
关注
  • 25
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二叉树的非递归和递归遍历C语言详解.docx
12-17
这篇文档详细讲解了如何用C语言实现二叉树的非递归和递归遍历。 首先，二叉树的节点通常由一个结构体表示，例如在文档中给出的`NODE`结构体： ```c typedef struct NODE{ int val; struct NODE* left; struct ...
二叉树的非递归和递归遍历C语言详解.pdf
12-17
非递归遍历通常使用栈来辅助实现。在先根遍历的非递归版本 `RootFirstTrav_` 中，首先创建一个栈，然后将根节点压入栈中。在主循环中，当栈不为空或仍有待访问的节点时，会持续处理。对于每个节点，我们首先处理它，...
二叉树的非递归后序遍历算法实例详解
09-04
二叉树的后序遍历是一种重要的树遍历方式，尤其在非递归实现中，其逻辑相对复杂。本文将详细解析非递归后序遍历的算法实例，帮助理解其实现过程。 后序遍历的基本顺序是：左子树 -> 右子树 -> 根节点，但在非递归...
深入遍历二叉树的各种操作详解（非递归遍历）
01-01
先使用先序的方法建立一棵二叉树，然后分别使用递归与非递归的方法实现前序、中序、后序遍历二叉树，并使用了两种方法来进行层次遍历二叉树，一种方法就是使用STL中的queue，另外一种方法就是定义了一个数组队列，...
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 381
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
C语言：刷题笔记
weixin_45930573的博客
09-04 253
c语言刷题记录
LeetCode LCR088.使用最小花费爬楼梯
m0_63816268的博客
09-03 827
动态规划
第四讲：拟合算法
PGeorge6的博客
09-03 1193
与插值问题不同，在拟合问题中不需要曲线一定经过给定的点。拟合问题的目标是寻求一个函数(曲线)使得该曲线在某种准则下与所有的数据点最为接近，即曲线拟合的最好(最小化损失函数)。插值算法中，得到的多项式f(x)要经过所有样本点。但是如果样本点太多，那么这个多项式次数过高，会造成龙格现象。尽管我们可以选择分段的方法避免这种现象，但是更多时候我们更倾向于得到-个确定的曲线，尽管这条曲线不能经过每一个样本点，但只要保证误差足够小即可，这就是拟合的思想。(拟合的结果是得到一个确定的曲线)
力扣刷题--1534. 统计好三元组【简单】
m0_75266675的博客
09-04 206
力扣刷题--1534. 统计好三元组【简单】
P7492 [传智杯 #3 决赛] 序列
summ1ts的博客
09-03 238
的数组，表示区间内所有数的二进制表示下某一位是否为1，但这太难写，最后无奈去看官方题解，发现只要维护区间所有数的按位与和And，如果(And&k)==k的话那就不用修改了。那样的话这个题就很简单了，维护最大子段和可以见。一道类似势能线段树的题，区间按位或上k，不满足区间可合并的性质，只能暴力的单点修改。，如果我们能找到一个方法，能够判定区间里的数，或上k后是否有改变，就可以避免。至于时间复杂度用类似势能分析的方法分析一波就行了，时间复杂度。我一开始想的是线段树里维护一个。但是考虑按位或的性质，
【算法】单词出现次数和位置统计
最新发布
Hanbuhuic的博客
09-04 192
编写一个程序，用于统计一个给定单词在一段文本中出现的次数以及第一次出现的位置。如果单词在文本中出现，则输出出现次数和第一次出现的位置（位置从0开始计算）。如果单词没有出现，则输出-1。
精选算法编程题
A18937260063的博客
08-30 3723
数组编程
算法的学习笔记—把数字翻译成字符串
业精于勤，荒于嬉
08-31 935
通过动态规划的方法，我们可以高效地计算出一个数字字符串有多少种不同的翻译方法。这个问题不仅考察了我们对动态规划的理解，还让我们熟悉了如何处理字符串中的边界情况和状态转移。希望通过这个例子的讲解，能够帮助你更好地理解动态规划的应用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybit欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论
[E二叉树] lc110. 平衡二叉树(dfs+自底向上)
Y-puyu 的博客
08-31 382
【代码】[E二叉树] lc110. 平衡二叉树(dfs+自底向上)
[排序和二分] 绝对差值和
StudyingPanda的博客
08-31 516
我们不妨取出一个局部去观察，首先，对于任意一个位置的i，abs(nums1[i]-nums2[i])就是这个位置对于答案的贡献，如果我们用j位置的数去置换掉i位置（0<=i,j<n，其中n为nums1数组的长度），那么这个位置的贡献就变成了abs(nums1[j]-nums2[i])。其实也比较容易发现，我们只需要让nums1[j]接近nums2[i]即可，也就是说我们二分查找一下nums1数组中和nums2[i]接近的两个数（可能更小，也可能更大），然后比较哪个更小即可。将第一个元素替换为第二个元素：[
【CSP】坐标变换2(问题拆解,快速输入,知识补充)
weixin_72391681的博客
08-30 3591
总结在这道题目中，我们通过旋转矩阵公式解决了二维平面上的坐标旋转问题，并且通过对浮点数的精度控制，满足了输出精度要求。我们还讨论了如何通过设定缓冲区和自定义输入函数优化大规模数据的输入输出效率。启发几何问题的推广：旋转矩阵的思路不仅适用于二维旋转，还可以推广到三维或更高维度的旋转问题，甚至可以应用于计算机图形学中的各种变换操作。精度控制的重要性：在涉及到浮点数运算的题目中，精度控制是至关重要的。了解并合理使用C++中的格式化输出可以有效避免因为精度丢失导致的错误。高效输入输出的技巧。
977.有序数组的平方
argcargv的博客
08-31 222
将双指针l、r分别从头和尾向中间移动（简化了很多，不用再处理边界条件）：基本相同写法（将双指针从中将最小值的下表，向两边移动）组成的新数组，要求也按。
树上dp+分组背包类问题
2301_80475191的博客
08-29 3473
今天也是无意间看到了一个树上dp+分组背包类的问题，有些难度的，不好想的嘞，话不多说直接看题。
9.4练习
GSCSDNeo的博客
09-04 363
208888定义了一个结构体SIGint newfd;// 存储新的文件描述符// 存储客户端信息} SIG;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值