C语言版：二叉树的前序，中序，后序非递归遍历实现

最新推荐文章于 2023-04-20 10:41:25 发布
最新推荐文章于 2023-04-20 10:41:25 发布
阅读量1k 收藏 19
点赞数 13
分类专栏： 笔记 文章标签： 二叉树 指针 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53318344/article/details/118565239
版权

数据结构：两种遍历方式， 递归和非递归，各有优缺点，都需要掌握。

文章目录

一、辅助工具

这里需要使用前面文章讲到的栈，利用栈的先进后出的原则，去控制结点的访问。下面就是栈的建立

//栈的建立和基本操作
typedef struct Stack
{
    RTreeNode * sa[MAX];		//存储的元素都是结点
    int top;
}RStack;

//生成一个栈
RStack * init()
{
    RStack *SS;
    SS = (struct Stack*)malloc(sizeof(struct Stack));
    SS->top = 0;
    return SS;
}

//进栈
void push(RStack *p, RTreeNode *x)
{
    if(p->top == MAX)
    {
        printf("栈满");
        exit(0);
    }
    p->sa[p->top] = x;
    ++p->top;
}

//判断是否栈空
bool isEmpty(RStack p)
{
    if(p.top == 0)
    {
        return true;
    }
    return false;
}

//出栈
RTreeNode *pop(RStack *p)
{
    if(isEmpty(*p))
    {
        printf("栈空");
        exit(0);
    }
    return p->sa[--p->top];
}

//清空栈
void clear(RStack *p)
{
    p->top = 0;
}

RTreeNode *GetTop(Stack *S)
{
    if(!isEmpty(*S))
    {
        return S->sa[S->top - 1];       //这里取栈顶元素不需要对栈进行操作
    }
    return NULL;
}

二、递归和非递归的区别

递归：优点简洁明了，代码少。缺点占用计算机资源，执行效率低。 非递归：优点：执行效率高，扩展性强，能够解决一些常见的问题。 缺点：代码多，理解起来比较困难。

三、三种非递归实现过程

1.前序非递归遍历

代码如下（示例）：

前序非递归遍历（先遍历根，在遍历左，把右结点的存储在栈中，
最后进行打印 满足了根 左 右）

void front_f_d_preorder(RTreeNode *root)
{
    RStack *S = init();
    push(S, root);
    RTreeNode *p = root;    //设置为根结点
    while(!p || !isEmpty(*S))
    {
        while(p != NULL)
        {
            printf("->%c", p->data);
            if(p->right_child != NULL)
            {
                push(S, p->right_child);    //利用栈的先进后出原则，右子树先进去，反而后出来（保存右结点）
            }
            p = p->left_child;
        }   //遍历左子树的所以左结点  把右结点全部压进栈中
        if(!isEmpty(*S))
        {
            p = pop(S); //右结点出栈
        }
    }
}

2.中序非递归遍历

代码如下（示例）：

中序非递归遍历（左 根 右， 先将根 和 左结点压入栈中，
出栈， 然后在判断是否有右子树，有压入栈中，没有进行下一次循环）

void center_f_d_preorder(RTreeNode *root)
{
    RStack *S = init();
    RTreeNode *p = root;       //移动结点
    RTreeNode *q = NULL;       //临时存储出栈结点
    while(p || !isEmpty(*S))
    {
        while(p != NULL)
        {
            push(S,p);
            p = p->left_child;
        }
        while(!isEmpty(*S))
        {
            q = pop(S);
            printf("->%c", q->data);
            if(q->right_child != NULL)
            {
                p = q->right_child; //右子树也需要压入栈中
            }
        }
    }
}

3.后序非递归遍历

代码如下（示例）：

后序非递归遍历（左 右 根， 对每个结点都判断是否有右结点，
有压入栈中，将指针赋值给左结点，在压入栈中，每个结点都进行判断）

void after_f_d_preorder(RTreeNode *root)
{
    Stack *S = init();
    RTreeNode *p, *r;
    p = root;       //移动指针
    r = NULL;       //上一次访问的记录（临时指针）
    while(p || !isEmpty(*S))
    {
        if(p != NULL){
            push(S,p);
            p = p->left_child;
        }else{
            p = GetTop(S);  //取栈顶元素
            if(p->right_child != NULL && p->right_child != r)       //判断每一个左结点是否右右子树
            {
                p = p->right_child;     //右结点压入栈中
                push(S,p);
                p = p->left_child;      //左结点压入栈中
            }else{
                p = pop(S);
                printf("->%c", p->data);
                r = p;
                p = NULL;       //结束循环
            }
        }
    }
}

本次非递归遍历的图：在这里插入图片描述

四、代码实现

代码如下（示例）：

//
// Created by xoo on 2021/7/7.
//
//采用静态建立二叉树，非递归实现
#include<stdio.h>
#include<stdlib.h>
#include<string>
#define MAX 50

typedef struct TreeNode
{
    struct TreeNode *left_child, *right_child;
    char data;
}RTreeNode;

RTreeNode *init_node(char data, RTreeNode *left_child, RTreeNode *right_child)
{
    RTreeNode *node;
    node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->left_child = left_child;
    node->right_child = right_child;
    node->data = data;
    return node;
}

//生成一课二叉树
RTreeNode *create_tree()
{
    RTreeNode *root, *b, *c, *d, *e, *f;
    d = init_node('D', NULL, NULL);
    e = init_node('E', NULL, NULL);
    f = init_node('F', NULL, NULL);
    b = init_node('B', d, NULL);
    c = init_node('C', e, f);
    root = init_node('A', b, c);
    return root;
}

typedef struct Stack
{
    RTreeNode * sa[MAX];
    int top;
}RStack;

//生成一个栈
RStack * init()
{
    RStack *SS;
    SS = (struct Stack*)malloc(sizeof(struct Stack));
    SS->top = 0;
    return SS;
}

//进栈
void push(RStack *p, RTreeNode *x)
{
    if(p->top == MAX)
    {
        printf("栈满");
        exit(0);
    }
    p->sa[p->top] = x;
    ++p->top;
}

//判断是否栈空
bool isEmpty(RStack p)
{
    if(p.top == 0)
    {
        return true;
    }
    return false;
}

//出栈
RTreeNode *pop(RStack *p)
{
    if(isEmpty(*p))
    {
        printf("栈空");
        exit(0);
    }
    return p->sa[--p->top];
}

//清空栈
void clear(RStack *p)
{
    p->top = 0;
}

//取栈顶元素
RTreeNode *GetTop(Stack *S)
{
    if(!isEmpty(*S))
    {
        return S->sa[S->top - 1];       //这里取栈顶元素不需要对栈进行操作
    }
    return NULL;
}
//前序非递归遍历（先遍历根，在遍历左，把右结点的存储在栈中，最后进行打印 满足了根 左 右）
void front_f_d_preorder(RTreeNode *root)
{
    RStack *S = init();
    push(S, root);
    RTreeNode *p = root;    //设置为根结点
    while(!p || !isEmpty(*S))
    {
        while(p != NULL)
        {
            printf("->%c", p->data);
            if(p->right_child != NULL)
            {
                push(S, p->right_child);    //利用栈的先进后出原则，右子树先进去，反而后出来（保存右结点）
            }
            p = p->left_child;
        }   //遍历左子树的所以左结点  把右结点全部压进栈中
        if(!isEmpty(*S))
        {
            p = pop(S); //右结点出栈
        }
    }
}

//中序非递归遍历（左 根 右， 先将根 和 左结点压入栈中，出栈， 然后在判断是否有右子树，有压入栈中，没有进行下一次循环）
void center_f_d_preorder(RTreeNode *root)
{
    RStack *S = init();
    RTreeNode *p = root;       //移动结点
    RTreeNode *q = NULL;       //临时存储出栈结点
    while(p || !isEmpty(*S))
    {
        while(p != NULL)
        {
            push(S,p);
            p = p->left_child;
        }
        while(!isEmpty(*S))
        {
            q = pop(S);
            printf("->%c", q->data);
            if(q->right_child != NULL)
            {
                p = q->right_child; //右子树也需要压入栈中
            }
        }
    }
}

//后序非递归遍历（左 右 根， 对每个结点都判断是否有右结点，有压入栈中，将指针赋值给左结点，在压入栈中，每个结点都进行判断）
void after_f_d_preorder(RTreeNode *root)
{
    Stack *S = init();
    RTreeNode *p, *r;
    p = root;       //移动指针
    r = NULL;       //上一次访问的记录（临时指针）
    while(p || !isEmpty(*S))
    {
        if(p != NULL){
            push(S,p);
            p = p->left_child;
        }else{
            p = GetTop(S);  //取栈顶元素
            if(p->right_child != NULL && p->right_child != r)       //判断每一个左结点是否右右子树
            {
                p = p->right_child;     //右结点压入栈中
                push(S,p);
                p = p->left_child;      //左结点压入栈中
            }else{
                p = pop(S);
                printf("->%c", p->data);
                r = p;
                p = NULL;       //结束循环
            }
        }
    }
}

//先序遍历
void front_preorder(RTreeNode *p)
{
    if(p != NULL){
        printf("->%c", p->data);
        front_preorder(p->left_child);
        front_preorder(p->right_child);
    }
}

//中序遍历
void center_preorder(RTreeNode *p)
{
    if(p != NULL){
        center_preorder(p->left_child);
        printf("->%c", p->data);
        center_preorder(p->right_child);
    }
}

//后序遍历
void after_preorder(RTreeNode *p)
{
    if(p != NULL){
        after_preorder(p->left_child);
        after_preorder(p->right_child);
        printf("->%c", p->data);
    }
}

int main() {
    RTreeNode *tree;
    tree = create_tree();
    printf("非递归的前序遍历：");
    front_f_d_preorder(tree);
    printf("\n");
    printf("递归的前序遍历：");
    front_preorder(tree);
    printf("\n");
    printf("非递归的中序遍历：");
    center_f_d_preorder(tree);
    printf("\n");
    printf("递归的中序遍历：");
    center_preorder(tree);
    printf("\n");
    printf("非递归的后序遍历：");
    after_f_d_preorder(tree);
    printf("\n");
    printf("递归的后序遍历：");
    after_preorder(tree);
    printf("\n");
    system("pause");
    return 0;
}

结果展示：在这里插入图片描述

总结

非递归的运用有很多，所以一定好好掌握，前序和中序非递归是容易理解的，后序非递归比较难理解，所以一定需要注重画图，具体的思路可以去某站上搜索。

历飞雨_smile
关注
  • 13
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
二叉树前序、中序、后序三种遍历的非递归算法（C语言）
12-29
二叉树前序、中序、后序三种遍历的非递归算法（C语言）
二叉树前序、中序、后序非递归遍历实现（C语言）
areen7003的博客
05-27 630
一、非递归前序遍历 void TreversePreorder(struct BTree *T) { struct BTree *stack[1000],*p=T; int top=0; while(p||top) { if(p) { printf("%d ",...
二叉树非递归先序、中序、后序遍历的完整C实现
taynpg的博客
03-04 1379
介绍 本文使用C语言完整实现二叉树的非递归先序、中序、后序遍历。 以下是原递归算法（二叉树的先序、中序、后序遍历的递归实现算法）： // 1.先序递归实现算法 void PreOrder(BiTree T) { if (T != NULL) { visit(T); PreOrder(T->lchild); PreOrder(T->rchild); } } // 2.中序递归实现算法 void InOrder(BiTree T) { if (T != NULL) { InO
C语言非递归实现二叉树的先序，中序，后序遍历
qq_66923597的博客
04-20 669
在下还只是初学者，也是想分享自己所学习到的知识。如有错误欢迎指正。
二叉树的前序中序后序递归遍历和非递归遍历（c语言版本）
weixin_43897882的博客
05-31 477
直接上代码，可以直接运行。 #include <stdio.h> #include<string.h> #include <stdlib.h> #include <stdbool.h> /**二叉树数据结构定义**/ struct treenode { char val; struct treenode *left; struct treenode *right; }treenode; //建立二叉树 struct treenode*
非递归前序,中序,后序遍历二叉树(优化算法).rar_nooneyh_二叉树 非递归_前序 中序 后序_树遍历算法_遍历二叉树
09-14
非递归前序,中序,后序遍历二叉树(优化算法)
二叉树的遍历:前序、中序、后序非递归遍历;从上至下，从左向右层次遍历;从上至下，从右向左层次遍历
05-16
（1）建立的二叉树； 节点的结构体为： typedef struct ...（2）完成二叉树前序、中序、后序非递归遍历程序；从上至下，从左向右层次遍历;从上至下，从右向左层次遍历; （3）给出程序和每种遍历程序的结果。
关于二叉树前序和后序的非递归遍历算法.rar
02-18
关于二叉树前序和后序的非递归遍历算法.rar
C++ 数据结构二叉树（前序/中序/后序递归、非递归遍历）
12-31
C++ 数据结构二叉树（前序/中序/后序递归、非递归遍历） 二叉树的性质： 二叉树是一棵特殊的树，二叉树每个节点最多有两个孩子结点，分别称为左孩子和右孩子。 例： 实例代码： #include #include #include ...
Python实现二叉树前序、中序、后序及层次遍历示例代码
12-26
递归实现先序遍历、中序遍历、后序遍历 堆栈实现先序遍历、中序遍历、后序遍历 队列实现层次遍历 # -*- coding=utf-8 -*- class Node(object): """节点类""" def __init__(self, element=-1, l_child=None, r_...
C++ 二叉树的先序遍历、中序遍历和后序遍历非递归算法
08-25
用C++写的，包括二叉树的构建，二叉树的先序遍历、中序遍历和后序遍历非递归算法。
c语言实现二叉树的前中后序遍历 递归和非递归 数据结构
03-23
1.输入前序和中序遍历结果，建立二叉树 2.实现二叉树的三种递归遍历算方法 3.实现二叉树的三种非递归遍历算法 4.实现二叉树的旋转90°后的打印，直观树形结构
二叉树先序、中序、后序遍历（递归、非递归算法）
05-10
二叉树先序、中序、后序遍历（递归、非递归算法） 其中自己已经开发了栈！
二叉树三种遍历的非递归算法
alfredtofu的专栏
01-11 817
<br />1.先序遍历非递归算法 #define maxsize 100 typedef struct { Bitree Elem[maxsize]; int top; }SqStack; void PreOrderUnrec(Bitree t) { SqStack s; StackInit(s); p=t; while (p!=null || !StackEmpty(s)) { while (
c语言二叉树前序中序后序非递归算法,【二叉树】非递归遍历的通用算法：前序、中序和后序...
weixin_32340879的博客
05-25 288
其实二叉树的3种遍历策略，无非是处理节点的时机不同：前序遍历是在遇到节点时即处理，中序是在处理完左节点后再处理，而后序是在处理完左右节点后再处理。使用非递归方法实现时，除了记录当前的节点的访问栈，还需要记录当前节点的状态。对于每一个节点，我们用0来表示尚未处理左右子节点，1表示仅仅处理完毕左节点，2表示左右节点都处理完毕。那么，前序，中序，后序遍历的唯一不同，无非是将节点加入序列化结果集合的时机不...
二叉树的非递归先序，中序，后序遍历
Fly Follow the Heart
09-27 763
二叉树的非递归遍历：         先序遍历，中序遍历，后序遍历 #include #include using namespace std; typedef struct node { char data; struct node *lchild; struct node *rchild; } BiNode, *BiTree; //先序递归创建树，这里
二叉树的前序、中序、后序遍历（非递归）
weixin_42237761的博客
02-08 1976
二叉树的前序、中序、后序遍历（非递归）
二叉树先序、中序，后序遍历的非递归实现
fanfan_fighting的博客
04-10 573
先序（前序）：中左右 中序：左中右 后序：左右中 1、递归方法 定义节点： 先序： 中序： 后序： 2、非递归方法：利用栈结构 先序： 1、先将头节点放入栈中，栈非空则弹出并且打印 2、然后放右节点，再放左节点，栈非空则弹出并且打印，该循环是在栈非空的情况下。 中序： 1、先将头节点压入栈中，然后头节点向左移动，不断将头节点压入栈中直到空； 2、到达空时，弹出栈顶并打印，然后头节点移动到右...
c++数据结构树的二叉树前序中序后序的递归与非递归代码
最新发布
06-06
好的，以下是C++数据结构树的二叉树前序、中序和后序遍历的递归和非递归实现代码。 ```c++ // 定义二叉树的结构体 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值