C语言实现二叉树非递归遍历 存储复杂数据类型 详细备注

最新推荐文章于 2024-04-10 05:43:48 发布
最新推荐文章于 2024-04-10 05:43:48 发布
阅读量473 收藏
点赞数 1
分类专栏： C语言数据结构 文章标签： c语言 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jakercl/article/details/125773390
版权

本文主要实现C语言二叉树的构造，存储复杂数据类型，通过栈对其进行非递归遍历，有详细备注。

1 二叉树构造

typedef struct Student
{
    int id;
    char name[10];
} Student;
typedef struct Tree
{
    Student *data;//暂存储Student*
    struct Tree *left;
    struct Tree *right;
} Tree;

2 根据数据data创建树节点

Tree *createTreeNode(Student *stu)
{
    Tree *node = (Tree *)malloc(sizeof(Tree *));
    node->left = NULL;
    node->right = NULL;
    node->data = stu;
}

3 中序遍历代码（文末有详细流程）

void inOrderList(Tree *root) //中序遍历，先左、后根、再右
{
    Tree **stk = (Tree **)malloc(sizeof(Tree *) * SIZE); //向堆区申请内存构造栈，栈内存储节点地址Tree*
    int top = 0;
    while (root != NULL || top > 0) //当root==NULL且top==0说明栈内已经没有元素，且没有新元素再入栈，跳出循环
    {
        while (root != NULL) //一直入栈，直到root=NULL，
        {
            stk[top++] = root; //先是根节点入栈//栈顶索引top不断增加
            root = root->left; //然后传入左子节点，左子树入栈//这样出栈时是左子树先出栈，根节点后出栈
        }                      //循环结束时，root及root.left全部入栈//栈顶索引top比实际值大1
        root = stk[--top];     //获取到栈顶的节点
        //上2次陆续入栈的是root和root->left，栈顶获取的是后者
        printf("{id:%d name:%s}  ", root->data->id, root->data->name); //输出栈顶,输出root
        root = root->right;                                            //再将栈顶的右子节点传入循环
    }
}

4 前序遍历代码

void preOrderList(Tree *root) //前序遍历，先根，后左，再右
{
    Tree **stk = (Tree **)malloc(sizeof(Tree *) * SIZE); //向堆区申请内存构造栈，栈内存储节点地址Tree*
    int top = 0;
    while (root != NULL || top > 0) //当root==NULL且top==0说明栈内已经没有元素，且没有新元素再入栈，跳出循环
    {
        while (root != NULL) //一直入栈，直到root=NULL，
        {
            stk[top++] = root;                                             //根节点入栈//栈顶索引top不断增加
            printf("{id:%d name:%s}  ", root->data->id, root->data->name); //输出栈顶root
            root = root->left;                                             //然后传入左子节点，左子树入栈//这样出栈时根节点先出，左子树再出栈
        }
        root = stk[--top];  //获取到栈顶的节点
        root = root->right; //再将栈顶的右子节点传入循环，右子树入栈前相应节点左子树已完成出栈操作
    }
}

5 后序遍历代码

  • 中序遍历中，从栈中弹出的节点，其左子树是访问完了，可以直接访问该节点，然后接下来访问右子树。
  • 后序遍历中，从栈中弹出的节点，我们只能确定其左子树肯定访问完了，但是无法确定右子树是否访问过。
  • 因此，我们在后序遍历中，引入了一个preNode来记录历史访问记录。
  • 当访问完一棵子树的时候，我们用preNode指向该节点。
  • 这样，在回溯到父节点的时候，我们可以依据preNode是指向左子节点，还是右子节点，来判断父节点的访问情况。
  • 主要思想如下：
  • 由于在某颗子树访问完成以后，接着就要回溯到其父节点去
  • 因此可以用prev来记录访问历史，在回溯到父节点时，可以由此来判断，上一个访问的节点是否为右子树
void postOrderList(Tree *root) //后序遍历，先左，后右，再根
{
    Tree **stk = (Tree **)malloc(sizeof(Tree *) * SIZE); //向堆区申请内存构造栈，栈内存储节点地址Tree*
    int top = 0;
    Tree *preNode = NULL;
    while (root != NULL || top > 0) //当root==NULL且top==0说明栈内已经没有元素，且没有新元素再入栈，跳出循环
    {
        while (root != NULL) //一直入栈，直到root=NULL，
        {
            stk[top++] = root; //根节点入栈//栈顶索引top不断增加
            root = root->left; //然后传入左子节点，左子树入栈//这样出栈时是左子树先出栈，根节点后出栈
        }
        //从栈中弹出的元素，左子树一定是访问完了的
        root = stk[--top]; //获取到栈顶的节点
        //现在需要确定的是是否有右子树，或者右子树是否访问过
        //如果没有右子树，或者右子树访问完了，也就是上一个访问的节点是右子节点时
        //说明可以访问当前节点
        if (root->right == NULL || root->right == preNode)
        {
            printf("{id:%d name:%s}  ", root->data->id, root->data->name); //输出栈顶root
            preNode = root;                                                //更新历史访问记录，这样回溯的时候父节点可以由此判断右子树是否访问完成
            root = NULL;
        }
        else //如果右子树没有被访问，那么将当前节点压栈，访问右子树
        {
            stk[top++] = root;
            root = root->right;
        }
    }
}

6 总体测试代码

#include <stdio.h>
#include <stdlib.h>
#define SIZE 100
typedef struct Student
{
    int id;
    char name[10];
} Student;
typedef struct Tree
{
    Student *data;
    struct Tree *left;
    struct Tree *right;
} Tree;
Tree *createTreeNode(Student *stu)
{
    Tree *node = (Tree *)malloc(sizeof(Tree *));
    node->left = NULL;
    node->right = NULL;
    node->data = stu;
}
void inOrderList(Tree *root) //中序遍历，先左、后根、再右
{
    Tree **stk = (Tree **)malloc(sizeof(Tree *) * SIZE); //向堆区申请内存构造栈，栈内存储节点地址Tree*
    int top = 0;
    while (root != NULL || top > 0) //当root==NULL且top==0说明栈内已经没有元素，且没有新元素再入栈，跳出循环
    {
        while (root != NULL) //一直入栈，直到root=NULL，
        {
            stk[top++] = root; //先是根节点入栈//栈顶索引top不断增加
            root = root->left; //然后传入左子节点，左子树入栈//这样出栈时是左子树先出栈，根节点后出栈
        }                      //循环结束时，root及root.left全部入栈//栈顶索引top比实际值大1
        root = stk[--top];     //获取到栈顶的节点
        //上2次陆续入栈的是root和root->left，栈顶获取的是后者
        printf("{id:%d name:%s}  ", root->data->id, root->data->name); //输出栈顶,输出root
        root = root->right;                                            //再将栈顶的右子节点传入循环
    }
}
void preOrderList(Tree *root) //前序遍历，先根，后左，再右
{
    Tree **stk = (Tree **)malloc(sizeof(Tree *) * SIZE); //向堆区申请内存构造栈，栈内存储节点地址Tree*
    int top = 0;
    while (root != NULL || top > 0) //当root==NULL且top==0说明栈内已经没有元素，且没有新元素再入栈，跳出循环
    {
        while (root != NULL) //一直入栈，直到root=NULL，
        {
            stk[top++] = root;                                             //根节点入栈//栈顶索引top不断增加
            printf("{id:%d name:%s}  ", root->data->id, root->data->name); //输出栈顶root
            root = root->left;                                             //然后传入左子节点，左子树入栈//这样出栈时根节点先出，左子树再出栈
        }
        root = stk[--top];  //获取到栈顶的节点
        root = root->right; //再将栈顶的右子节点传入循环，右子树入栈前相应节点左子树已完成出栈操作
    }
}
/**
中序遍历中，从栈中弹出的节点，其左子树是访问完了，可以直接访问该节点，然后接下来访问右子树。
后序遍历中，从栈中弹出的节点，我们只能确定其左子树肯定访问完了，但是无法确定右子树是否访问过。
因此，我们在后序遍历中，引入了一个preNode来记录历史访问记录。
当访问完一棵子树的时候，我们用preNode指向该节点。
这样，在回溯到父节点的时候，我们可以依据preNode是指向左子节点，还是右子节点，来判断父节点的访问情况。
主要思想：
由于在某颗子树访问完成以后，接着就要回溯到其父节点去
因此可以用prev来记录访问历史，在回溯到父节点时，可以由此来判断，上一个访问的节点是否为右子树
 */
void postOrderList(Tree *root) //后序遍历，先左，后右，再根
{
    Tree **stk = (Tree **)malloc(sizeof(Tree *) * SIZE); //向堆区申请内存构造栈，栈内存储节点地址Tree*
    int top = 0;
    Tree *preNode = NULL;
    while (root != NULL || top > 0) //当root==NULL且top==0说明栈内已经没有元素，且没有新元素再入栈，跳出循环
    {
        while (root != NULL) //一直入栈，直到root=NULL，
        {
            stk[top++] = root; //根节点入栈//栈顶索引top不断增加
            root = root->left; //然后传入左子节点，左子树入栈//这样出栈时是左子树先出栈，根节点后出栈
        }
        //从栈中弹出的元素，左子树一定是访问完了的
        root = stk[--top]; //获取到栈顶的节点
        //现在需要确定的是是否有右子树，或者右子树是否访问过
        //如果没有右子树，或者右子树访问完了，也就是上一个访问的节点是右子节点时
        //说明可以访问当前节点
        if (root->right == NULL || root->right == preNode)
        {
            printf("{id:%d name:%s}  ", root->data->id, root->data->name); //输出栈顶root
            preNode = root;                                                //更新历史访问记录，这样回溯的时候父节点可以由此判断右子树是否访问完成
            root = NULL;
        }
        else //如果右子树没有被访问，那么将当前节点压栈，访问右子树
        {
            stk[top++] = root;
            root = root->right;
        }
    }
}
int main()
{
    Student stu[7] = {
        {1, "jakes1"},
        {2, "jakes2"},
        {3, "jakes3"},
        {4, "jakes4"},
        {5, "jakes5"},
        {6, "jakes6"},
        {7, "jakes7"},
    };
    Tree *root = (Tree *)malloc(sizeof(Tree));
    root->data = &stu[0];
    root->left = createTreeNode(&stu[1]);
    root->right = createTreeNode(&stu[2]);
    root->left->left = createTreeNode(&stu[3]);
    root->left->left->right = createTreeNode(&stu[6]);
    root->right->left = createTreeNode(&stu[4]);
    root->right->right = createTreeNode(&stu[5]); //完成一棵树的构建
    printf("中序遍历:\n");
    inOrderList(root);
    puts("");
    printf("前序遍历:\n");
    preOrderList(root);
    puts("");
    printf("后序遍历:\n");
    postOrderList(root);
    return 0;
}

7 以中序遍历为例解析

主函数中构造的二叉树如下：

 前序遍历通过栈实现，执行流程如下：（三种遍历方式均可通过这种方式理解）

 main函数测试输出如下：

 

jakerc
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉树的非递归遍历（C语言实现）
lihongzhihhh的博客
04-21 2万+
上一篇讨论了二叉树的的递归遍历，这一次讨论二叉树的三种非递归遍历二叉树的非递归遍历采用栈实现，首先给出二叉树和栈的定义#define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 typedef char lElemType; typedef struct BiTNode { lElemType data; struct BiTNode *lchi...
C语言：二叉树的非递归调用
qq_41939099的博客
04-23 216
#include <stdio.h> #include <stdlib.h> //---------------------------------树---------------------------------------- typedef struct Node{ int data; struct Node *leftchild; st...
C语言数据结构：非递归遍历二叉树
no_pain_no_gain_的博客
05-28 682
非递归遍历二叉树 这一部分内容并不难，可就是找不到完整的可实现代码教程，书上也只是粗略带过，不死心的我决定编程实现一下，也算是对我数据结构树遍历这一部分的检验。 查错排错还是花了不少时间，不多赘述，代码如下： #include<stdio.h> #include<string.h> #include<stdlib.h> #define elemtype char #define maxsize 50 ...
二叉树的三种非递归遍历方式（附C、java源码，字节跳动面试官问题
最新发布
2401_84104357的博客
04-10 577
学习技术一定要制定一个明确的学习路线，这样才能高效的学习，不必要做无效功，既浪费时间又得不到什么效率，大家不妨按照我这份路线来学习。大家不妨直接在牛客和力扣上多刷题，同时，我也拿了一些面试题跟大家分享，也是从一些大佬那里获得的，大家不妨多刷刷题，为金九银十冲一波！一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
数据结构之二叉树(C语言非递归实现)
qq_60856466的博客
09-17 595
C语言非递归二叉树的实现
c语言二叉链表的非递归建立,用非递归方法创建一个二叉树，再用递归方法先中后序遍历，然后用非递归层次遍历...
weixin_34007888的博客
05-21 189
include #define Null 0struct tree_node \\声明二差树节点结构{int data;struct tree_node *left;struct tree_node *right;};typedef struct tree_node tree_list;typedef tree_list *btree;struct s_node \\声明堆栈结构{btree...
C语言数据结构(5)：非递归插入以及遍历的二叉树实现
qq_37887488的博客
03-10 185
标准库以及类型定义 #include <stdio.h> #include <stdlib.h> typedef struct btree { int value; struct btree *left; struct btree *right; } btree; typedef struct stack { struct btree *...
C语言二叉树的非递归遍历实例分析
09-04
主要介绍了C语言二叉树的非递归遍历,包括了先序遍历、中序遍历与后序遍历,需要的朋友可以参考下
C++实现二叉树非递归遍历方法实例总结
09-04
主要介绍了C++实现二叉树非递归遍历方法实例总结,是算法设计中比较经典的一个遍历算法,需要的朋友可以参考下
C语言数据结构之二叉树的非递归后序遍历算法
01-01
C语言数据结构之二叉树的非递归后序遍历算法 前言： 前序、中序、后序的非递归遍历中，要数后序最为麻烦，如果只在栈中保留指向结点的指针，那是不够的，必须有一些额外的信息存放在栈中。 方法有很多，这里只举一...
数据结构 --- c语言非递归法遍历二叉树
weixin_60569662的博客
02-25 1822
通过队列实现，从上往下一层一层去遍历，A → B、C → D、E、F → G、H1.入队 2.打印数据A入队，打印：A 队列中的元素：A 打印结果：A A出队 判断 A->LChild != NULL，B != NULL，B入队 打印：B 队列中的元素：B 打印结果：A、B判断 A->RChild !=
遍历二叉树的非递归算法（C语言）
weixin_53068269的博客
04-25 1204
在遍历二叉树时，使用递归简单易懂，但会耗费更多的时间以及空间，可考虑使用消除递归的方法。 一般我们用循环来代替递归，但在一些较为复杂的情况下，普通的循环已经难以支撑我们的需求。例如此种情况，我们用工作栈的方式来消除递归。 下面是非递归的中序与后序遍历。 输入时，以#表示取消子树建立。 #include <stdio.h> #include <stdlib.h> #define StackMax 100 typedef struct Node { char data;
C语言经典算法之二叉树的后序遍历（非递归实现）
weixin_56154577的博客
01-31 1268
在C语言中，二叉树的后序遍历（LRD顺序：左子树-右子树-根节点）非递归实现通常依赖于栈来模拟递归过程。
c语言和c++实现二叉树非递归遍历
hou19975418的博客
01-18 513
结合栈结构来实现二叉树的非递归遍历，首先将根节点入栈，然后对栈内元素进行循环，弹出栈顶元素，根据链表结点携带的标志位flag来判断是对于结点进行打印还是后续的入栈操作。入栈顺序决定着实际的遍历方式。
数据结构——二叉树的非递归遍历
Wz_still_shuai的博客
04-16 740
二叉树的非递归遍历 一.非递归先序遍历 递归的方式遍历是指就是利用了函数压栈的特点，我们根据这个特点可以自己设计栈来实现非递归遍历的方式。 先序遍历的过程： 代码： //非递归的先序遍历 void preOrderNoR(TreeNode* root) { //从根节点进入，根节点入栈， //打印根节点，根节点出栈，并将根节点的非空左孩子入栈 //如果左孩子为空，就入其右孩子...
二叉树的非递归遍历（详解）
qq_45973003的博客
12-08 954
【代码】二叉树的非递归遍历（详解）
【数据结构】--- 二叉树的递归遍历和非递归遍历【C语言实现】
热门推荐
mike_jun的博客
07-17 3万+
目录 1. 创建一颗二叉树 2.递归前序遍历二叉树 3.递归中序遍历二叉树 4.递归后序遍历二叉树 5. 测试递归打印二叉树代码 6. 非-递归前序遍历二叉树 7.非-递归实现中序遍历二叉树 8.非 - 递归实现后序遍历【较为复杂的方法】 9.非 - 递归实现后序遍历【简单的方法】 10. 二叉树的层次遍历 11. 最后：附全部代码： 对于二叉树的非递归 深度优先遍历，使用的都是栈 对于二叉树的层次遍历，使用的是队列 1. 创建一颗二叉树 依据前序遍...
二叉树创建之先序法（非递归算法）入门详解（C语言版）
sunnyoldboy博客
07-19 8005
二叉树是一种非常重要的非线性数据结构，在信号处理、移动通讯等应用中均有重要的应用。 在二叉树的应用中，首先要建立二叉树。本文针对二叉树的先序建立过程给出了详细的实现过程，包括非递归算法和递归算法两种不同的实现模式。所谓的先序法，就是按照先序遍历二叉树的流程创建二叉树。使用的二叉树数据如下图所示。本文给出了C语言版本的先序创建二叉树的非递归算法。......
c语言实现二叉树非递归中序遍历算法
05-12
二叉树的中序遍历可以通过非递归的方式实现，常用的方法是利用栈。具体的实现方法如下： 1. 初始化一个栈，将根节点入栈。 2. 循环执行以下步骤，直到栈为空： 1. 将栈顶节点弹出，并将其右子节点（如果有）压...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

jakerc

原创不易，您的奖励将是我最大的

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值