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

最新推荐文章于 2024-01-31 08:59:12 发布
最新推荐文章于 2024-01-31 08:59:12 发布
阅读量494 收藏
点赞数 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函数测试输出如下：

 

2024华为OD机试卷(java\python\c++)全部+详细解析+机试攻略介绍
WRJ_Jack的博客
05-19 957
2024OD机试卷 (java\python\c++)全部题目目录
C语言：二叉树的非递归调用
qq_41939099的博客
04-23 242
#include <stdio.h> #include <stdlib.h> //---------------------------------树---------------------------------------- typedef struct Node{ int data; struct Node *leftchild; st...
C语言数据结构：非递归遍历二叉树
no_pain_no_gain_的博客
05-28 720
非递归遍历二叉树 这一部分内容并不难，可就是找不到完整的可实现代码教程，书上也只是粗略带过，不死心的我决定编程实现一下，也算是对我数据结构树遍历这一部分的检验。 查错排错还是花了不少时间，不多赘述，代码如下： #include<stdio.h> #include<string.h> #include<stdlib.h> #define elemtype char #define maxsize 50 ...
数据结构之二叉树(C语言非递归实现)
qq_60856466的博客
09-17 663
C语言非递归二叉树的实现
c语言二叉链表的非递归建立,用非递归方法创建一个二叉树，再用递归方法先中后序遍历，然后用非递归层次遍历...
weixin_34007888的博客
05-21 209
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 206
标准库以及类型定义 #include <stdio.h> #include <stdlib.h> typedef struct btree { int value; struct btree *left; struct btree *right; } btree; typedef struct stack { struct btree *...
C语言实现常用数据结构：简要一览（第1篇）
qq_43351159的博客
08-05 2102
线性表 最简单的一种数据结构，具有相同类型的数据元素组成的序列。顺序表、链表是其两种简单实现。 备注：数组也可以算一种简单的线性表。 链表可以分为： 带头结点的简单链表 不带头结点的简单链表 静态链表 循环链表 双向链表 栈 限定增加和删除数据操作只能在线性表的末端进行，因此是一种受限的特殊线性表。 实现方式有： 顺序栈 链栈 栈典型的特点是：数据“后进先出”，栈可以用来实现递归。栈数据结构的主要操作是出栈、入栈。 队列 限定增加数据元素在线性
家谱管理系统-数据结构大作业.pdf
05-28
此外，程序中还定义了宏MAXN（可能代表数组或节点的最大数量）、MAXMEM（内存大小限制），以及数据类型Elemtype（元素类型）来增强程序的可读性和可维护性。 总结而言，家谱管理系统不仅仅是对家谱数据的存储和展示...
数据结构の笔记
fishball030的博客
11-17 240
数据结构
中国矿业大学2018数据结构大纲
07-26
二叉树的递归和非递归操作、线索化、哈夫曼树等也是考察的内容。 9. 图的定义、存储结构和操作 图由顶点的有穷非空集合和顶点之间边的集合组成，用于表示多对多的关系。图的邻接表和邻接矩阵是常见的两种存储结构...
二叉树的非递归遍历（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语言非递归法遍历二叉树
weixin_60569662的博客
02-25 2073
通过队列实现，从上往下一层一层去遍历，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 1234
在遍历二叉树时，使用递归简单易懂，但会耗费更多的时间以及空间，可考虑使用消除递归的方法。 一般我们用循环来代替递归，但在一些较为复杂的情况下，普通的循环已经难以支撑我们的需求。例如此种情况，我们用工作栈的方式来消除递归。 下面是非递归的中序与后序遍历。 输入时，以#表示取消子树建立。 #include <stdio.h> #include <stdlib.h> #define StackMax 100 typedef struct Node { char data;
C语言经典算法之二叉树的后序遍历（非递归实现）
最新发布
weixin_56154577的博客
01-31 1538
在C语言中，二叉树的后序遍历（LRD顺序：左子树-右子树-根节点）非递归实现通常依赖于栈来模拟递归过程。
c语言和c++实现二叉树非递归遍历
hou19975418的博客
01-18 600
结合栈结构来实现二叉树的非递归遍历，首先将根节点入栈，然后对栈内元素进行循环，弹出栈顶元素，根据链表结点携带的标志位flag来判断是对于结点进行打印还是后续的入栈操作。入栈顺序决定着实际的遍历方式。
超详细面试准备（10分钟打遍所有初级后端开发面试）
weixin_44540766的博客
02-23 4792
面试知识汇总 如何介绍项目： https://www.sohu.com/a/259724527_775404 自我介绍：https://www.jianshu.com/p/008fc86a1f28 4W字的后端面试知识点总结： https://www.cnblogs.com/aobing/p/12849591.html 后端技术框架： https://www.cnblogs.com/loren-Yang/p/11073536.html 数据结构 Java HashMap原理： https://yikun.g
数据结构——二叉树的非递归遍历
Wz_still_shuai的博客
04-16 783
二叉树的非递归遍历 一.非递归先序遍历 递归的方式遍历是指就是利用了函数压栈的特点，我们根据这个特点可以自己设计栈来实现非递归遍历的方式。 先序遍历的过程： 代码： //非递归的先序遍历 void preOrderNoR(TreeNode* root) { //从根节点进入，根节点入栈， //打印根节点，根节点出栈，并将根节点的非空左孩子入栈 //如果左孩子为空，就入其右孩子...
二叉树的非递归遍历（详解）
qq_45973003的博客
12-08 1039
【代码】二叉树的非递归遍历（详解）
【数据结构】--- 二叉树的递归遍历和非递归遍历【C语言实现】
热门推荐
mike_jun的博客
07-17 3万+
目录 1. 创建一颗二叉树 2.递归前序遍历二叉树 3.递归中序遍历二叉树 4.递归后序遍历二叉树 5. 测试递归打印二叉树代码 6. 非-递归前序遍历二叉树 7.非-递归实现中序遍历二叉树 8.非 - 递归实现后序遍历【较为复杂的方法】 9.非 - 递归实现后序遍历【简单的方法】 10. 二叉树的层次遍历 11. 最后：附全部代码： 对于二叉树的非递归 深度优先遍历，使用的都是栈 对于二叉树的层次遍历，使用的是队列 1. 创建一颗二叉树 依据前序遍...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

jakerc

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

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

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

打赏作者

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

抵扣说明：

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

余额充值