二叉树递归非递归遍历（递归前中后，非递归前中后，层次遍历，凹入打印法等）

最新推荐文章于 2024-07-17 12:11:36 发布
最新推荐文章于 2024-07-17 12:11:36 发布
阅读量5k 收藏 11
点赞数 2
分类专栏： C 文章标签： 二叉树 递归 遍历 递归算法 结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaofei__/article/details/51417376
版权

由于所有的递归算法都可以借助于堆栈转换成循环结构的非递归算法。方法一：形式化模拟转换。方法二：根据要求解问题的特点设计借助于堆栈的循环结构算法。而此次正好是利用第二种按方法求解。

1.1非递归前序遍历：

首先利用下图来设计非递归前序遍历算法思想：
堆栈结构体如下：

#define size 100 
typedef struct
{
     DataType  data[size];
     int tag[100];     //这个是在非递归后序中用到
     int top ；
}SeqStack ；

(1)初始化设置一个堆栈。
(2)把根结点指针入栈。
(3)当堆栈非空，循环执行步骤①到步骤③：
①出栈取得一个结点指针，访问该结点；
②若该结点的右子树非空，则将该结点的右子树指针入栈；
③若该结点的左子树非空，则将该结点的左子树指针入栈；

void preOrder2(BiTreeNode *root)
{
    BiTreeNode *t;    
    SeqStack S;          //定义一个顺序堆栈
    StackInitiate(S);   
    StackPush(&S,root); 
    while(StackNotEmpty(S)!=NULL)
    {
        SatckPop(&S,&t);           //出栈访问
        printf("%3c",t->data);
        if(root->rightChild!=NULL)   //右孩子非空，右孩子入栈
        {
            SatckPush(&S,root->rightChild);
        }
        if(root->leftChild!=NULL)   //左孩子非空，左孩子入栈
        {
            StackPush(&S,root->leftChild);
        }
    }
}

1.2递归法前序遍历

递归法先序遍历思想：
若二叉树为空，则算法结束；否则：
①访问根结点；
②先序遍历根结点的左子树；
③先序遍历根结点的右子树

void PreOrder(BiTreeNode *root)
{
    if(root!=NULL)            //二叉树非空
    {
        printf("%c ",root->data);    //访问根结点；
        PreOrder(root->leftChild);   //先序遍历根结点的左子树
        PreOrder(root->rightChild);  //先序遍历根结点的右子树
    }
}

1.3层次遍历（与前序遍历基本相同，就是前序使用堆栈，层次遍历使用队列）

void LayOrder(BiTreeNode *root)           //层次遍历
{
    BiTreeNode *d;
    SeqCQueue Q;
    QueueInitiate(&Q);
    QueueAppend(&Q,root);
    while(QueueNotEmpty(Q))
    {
        QueueDelete(&Q,&d);
        printf("%3c",d->data);
        if(d->leftChild) QueueAppend(&Q,d->leftChild);
        if(d->rightChild) QueueAppend(&Q,d->rightChild);
    }

}

2.1非递归法中序遍历

利用下图来设计非递归中序遍历算法思想：
堆栈结构体如下：

#define size 100 
typedef struct
{
     DataType  data[size];
     int tag[100];     //这个是在非递归后序中用到
     int top ；
}SeqStack ；

(1)初始化设置一个堆栈。
(2)把根结点指针入栈。
(3)当堆栈非空或则指针t非空，循环执行步骤①到步骤③：
①若指针t非空，则将t入栈，一直遍历其左孩子；
②若堆栈非空，则弹出栈顶元素并访问，并指向其右孩子；

void InOrder(BiTreeNode *root)
{
    BiTreeNode *t;
    SeqStack S;
    StackInitiate(&S);
    StackPush(&S,root);
    t=root->leftChld;
    while(StackNotEmpty(S)!=NULL||t!=NULL)    //当堆栈非空或则指针t非空
    {
        while(t!=NULL)          
        {
            StackPush(&S,t);     //t入栈
            t=t->leftChild;      //遍历其左孩子
        }
        if(StackNotEmpty(S))
        {
            StackPop(&S,&t);    //弹出栈顶元素并访问，并指向其右孩子
            printf("%c",t->data);
            t=t->rightChild;
        }
    }
}

2.2二叉树的中序递归算法

递归法中序遍历思想：
若二叉树为空，则算法结束；否则：
①中序遍历根结点的左子树；
②访问根结点；
③中序遍历根结点的右子树

void InOrder(BiTreeNode *root)
{
    if(root!=NULL)      //二叉树非空
    {
        InOrder(root->leftChild);    //先序遍历根结点的左子树
        printf("%c",root->data);      //访问根结点；
        InOrder(root->rightChild);    //先序遍历根结点的右子树
    }
}

3.1二叉树的后序非递归遍历算法

后序遍历算法要明白的是，当访问结点的左子树是，该结点标志位0，之后获取（非弹出栈中的结点），访问其右子树，这是标志位为1.

void PostOrder2(BiTreeNode *root)
{
    SeqStack S;
    StackInitiate(&S);
    while((root!=NULL)||StackNotEmpty(S))
    {
        while(root)
        {
            StackPush(&S,root);       //访问结点的左子树时，tag为0
            S.tag[S.top]=0;
            root=root->leftChild;
        }

        while((StackNotEmpty(S))&&(S.tag[S.top]==1))
        {
            StackPop(&S,&root);
            printf("%3c",root->data);
        }
        if(StackNotEmpty(S))
        {
            StackTop(S,&root);      //获取栈顶元素
            S.tag[S.top]=1;         //tag为1
                root= root->rightChild;

        }
        else root=NULL;
    }
}

由于后序遍历的算法叫其他的遍历难，所以一定得自己画图，边体会代码的运行过程

3.2二叉树的递归后序

递归法后序遍历思想：
若二叉树为空，则算法结束；否则：
①后序遍历根结点的左子树；
②后序序遍历根结点的右子树；
③访问根结点

void PostOrder(BiTreeNode *root)
{
    if(root!=NULL)      //二叉树非空
    {
        InOrder(root->leftChild);    //先序遍历根结点的左子树
        InOrder(root->rightChild);    //先序遍历根结点的右子树
        printf("%c",root->data);      //访问根结点；
    }
}

4应用

main函数

#include<stdlib.h>
#include<stdio.h>
typedef char DataType;
#define MaxQueueSize 100
#define MaxStackSize 100
#include"BiTree.h"
#include"Queue.h"
#include"SeqStack.h"
#include"BiTreeTraverse.h"


void Visit(DataType item)        //用来输出字符，就是个printf语句
{
    printf("%c ",item);
}

void PrintBiTree(BiTreeNode *root,int n)     //打印二叉树，这里使用的是凹入表示法
{
    int i;
    if(root==NULL) return;
    PrintBiTree(root->rightChild,n+1);
    for(i=0;i<n-1;i++) printf("  ");
    if(n>0)
    {
        printf("---");
        printf("%c\n",root->data);
    }
    PrintBiTree(root->leftChild,n+1);
}

BiTreeNode *Search(BiTreeNode *root,DataType x)        //查找二叉树的某一个字符是否在该树种
{
    BiTreeNode *find=NULL;
    if(root!=NULL)
    {
        if(root->data==x)
            find=root;
        else
        {
            find=Search(root->leftChild,x);
            if(find==NULL)
                find=Search(root->rightChild,x);
        }
    }
    return find;
}


main()
{
    BiTreeNode *root,*p,*find;
    char x='E';
    Initiate(&root);
    p=InsertLeftNode(root,'A');
    p=InsertLeftNode(p,'B');
    p=InsertLeftNode(p,'D');
    p=InsertRightNode(p,'G');
    p=InsertRightNode(root->leftChild,'C');
    InsertLeftNode(p,'E');
    InsertRightNode(p,'F');
    PrintBiTree(root,0);
    printf("前序遍历：");
    PreOrder(root->leftChild,Visit);
    printf("\n中序遍历：");
    InOrder(root->leftChild,Visit);
    printf("\n后序遍历：");
    PostOrder(root->leftChild,Visit);
    printf("\n非递归前序遍历：");
    PreOrder2(root->leftChild);
    printf("\n非递归中序遍历：");
    InOrder2(root->leftChild);
    printf("\n非递归后序遍历：");
    PostOrder2(root->leftChild);
    printf("\n层次遍历：");
    LayOrder(root->leftChild);
    find=Search(root,x);
    if(find!=NULL)
        printf("\n数据元素%c在二叉树中\n",x);
    else
        printf("\n数据元素%c不在二叉树中\n",x);
    Destroy(&root);
}

队列

typedef struct
{
    BiTreeNode *queue[MaxQueueSize];
    int rear;
    int front;
    int count;
}SeqCQueue;


void QueueInitiate(SeqCQueue *Q)
{
    Q->rear=0;
    Q->front=0;
    Q->count=0;
}


int QueueNotEmpty(SeqCQueue Q)
{
    if(Q.count!=0) return 1;
    else return 0;
}


int QueueAppend(SeqCQueue *Q,BiTreeNode *x)
{
    if(Q->count>0&&Q->rear==Q->front)
    {
        printf("队列已满无法插入！\n");
        return 0;
    }
    else
    {
        Q->queue[Q->rear]=x;
        Q->rear=(Q->rear+1)%MaxQueueSize;
        Q->count++;
        return 1;
    }
}


int QueueDelete(SeqCQueue *Q,BiTreeNode **d)
{
    if(Q->count==0)
    {
        printf("队列已空无数据元素出队列！\n");
        return 0;
    }
    else
    {
        *d=Q->queue[Q->front];
        Q->front=(Q->front+1)%MaxQueueSize;
        Q->count--;
        return 1;
    }
}

堆栈

typedef struct
{
    BiTreeNode *stack[MaxStackSize];
    int tag[100];
    int top;       //top表示顺序堆栈数组stack的当前栈顶位置
}SeqStack;

void StackInitiate(SeqStack *S)
{
    S->top=0;    //初始化栈顶下标值
}

int StackNotEmpty(SeqStack S)  //判断顺序堆栈S是否为空，非空返回1，否则返回0
{
    if(S.top<=0)return 0;
    else return 1;
}

int StackPush(SeqStack *S,BiTreeNode *x)//把数据元素x存入顺序堆栈S中，入栈成功返回1，否则返回0
{
    if(S->top>=MaxStackSize)
    {
        printf("堆栈已满，无法插入！\n");
        return 0;
    }
    else
    {
        S->stack[S->top]=x;
        S->top++;
        return 1;
    }
}

int StackPop(SeqStack *S,BiTreeNode **d) //取出顺序堆栈S的栈顶元素值由参数d带回，出栈成功则返回1，否则返回0
{
    if(S->top<=0)
    {
        printf("堆栈已空无数据元素出栈！\n");
        return 0;
    }
    else
    {
        S->top--;        //得注意top--，--top的差别
        *d=S->stack[S->top];
        return 1;
    }
}

 int StackTop(SeqStack S,BiTreeNode **d) //取栈顶数据元素值由参数d带回，成功返回1，不成功返回0
{
        if(S.top<=0)
        {
            printf("堆栈已空！\n");
            return 0;
        }
        else
        {
            *d=S.stack[S.top-1];
            return 1;
        }
}

树的遍历等函数BiTreeTraverse.h

void PreOrder(BiTreeNode *root,void visit(DataType item))    //递归前序遍历
{
    if(root!=NULL)
    {
        visit(root->data);
        PreOrder(root->leftChild,visit);
        PreOrder(root->rightChild,visit);
    }
}


void InOrder(BiTreeNode *root,void visit(DataType item))     //递归中序遍历
{
    if(root!=NULL)
    {
        InOrder(root->leftChild,visit);
        visit(root->data);
        InOrder(root->rightChild,visit);
    }
}


void PostOrder(BiTreeNode *root,void visit(DataType item))     //递归后序遍历
{
    if(root!=NULL)
    {
        PostOrder(root->leftChild,visit);
        PostOrder(root->rightChild,visit);
        visit(root->data);
    }
}

void InOrder2(BiTreeNode *root)             //非递归中序遍历
{
    BiTreeNode *t;
    SeqStack S;
    StackInitiate(&S);
    StackPush(&S,root);
    t=root->leftChild;
    while(StackNotEmpty(S)||t!=NULL)
    {
        while(t!=NULL)
        {
            StackPush(&S,t);
            t=t->leftChild;
        }
        if(StackNotEmpty(S))
        {
            StackPop(&S,&t);
            printf("%3c",t->data);
            t=t->rightChild;
        }
    }
}

void PreOrder2(BiTreeNode *root)      //非递归中序遍历
{
    BiTreeNode *t;
    SeqStack S;
    StackInitiate(&S);
    StackPush(&S,root);
    while(StackNotEmpty(S))
    {
        StackPop(&S,&t);
        printf("%3c",t->data);
        if(t->rightChild!=NULL)
        {
            StackPush(&S,t->rightChild);
        }
        if(t->leftChild!=NULL)
        {
            StackPush(&S,t->leftChild);
        }
    }
}

void PostOrder2(BiTreeNode *root)    //非递归后序遍历
{
    SeqStack S;
    StackInitiate(&S);
    while((root!=NULL)||StackNotEmpty(S))
    {
        while(root)
        {
            StackPush(&S,root);
            S.tag[S.top]=0;
            root=root->leftChild;
        }

        while((StackNotEmpty(S))&&(S.tag[S.top]==1))
        {
            StackPop(&S,&root);
            printf("%3c",root->data);
        }
        if(StackNotEmpty(S))
        {
            StackTop(S,&root);
            S.tag[S.top]=1;
                root= root->rightChild;

        }
        else root=NULL;
    }
}

void LayOrder(BiTreeNode *root)           //层次遍历
{
    BiTreeNode *d;
    SeqCQueue Q;
    QueueInitiate(&Q);
    QueueAppend(&Q,root);
    while(QueueNotEmpty(Q))
    {
        QueueDelete(&Q,&d);
        printf("%3c",d->data);
        if(d->leftChild) QueueAppend(&Q,d->leftChild);
        if(d->rightChild) QueueAppend(&Q,d->rightChild);
    }

}

二叉树创建BiTree.h

typedef struct Node       //结构体的定义
{
    DataType data;
    struct Node *leftChild;
    struct Node *rightChild;
} BiTreeNode;

void Initiate(BiTreeNode **root)       //初始化
{
    *root=(BiTreeNode *)malloc(sizeof(BiTreeNode));
    (*root)->leftChild=NULL;
    (*root)->rightChild=NULL;
}

BiTreeNode *InsertLeftNode(BiTreeNode *curr,DataType x)    //左插入结点
{
    BiTreeNode *s,*t;
    if(curr==NULL) return NULL;
    t=curr->leftChild;
    s=(BiTreeNode *)malloc(sizeof(BiTreeNode));
    s->data=x;
    s->leftChild=t;
    s->rightChild=NULL;
    curr->leftChild=s;
    return curr->leftChild;
}

BiTreeNode *InsertRightNode(BiTreeNode *curr,DataType x)    //右插入结点
{
    BiTreeNode *s,*t;
    if(curr==NULL) return NULL;
    t=curr->rightChild;
    s=(BiTreeNode *)malloc(sizeof(BiTreeNode));
    s->data=x;
    s->rightChild=t;
    s->leftChild=NULL;
    curr->rightChild=s;
    return curr->rightChild;
}


void Destroy(BiTreeNode **root)               //撤销二叉树
{
    if((*root)!=NULL&&(*root)->leftChild!=NULL)
        Destroy(&(*root)->leftChild);
    if((*root)!=NULL&&(*root)->rightChild!=NULL)
        Destroy(&(*root)->rightChild);
    free(*root);
}


BiTreeNode *DeleteLeftTree(BiTreeNode *curr)        //左删除子树
{
    if(curr==NULL||curr->leftChild==NULL) return NULL;
    Destroy(&curr->leftChild);
    curr->leftChild=NULL;
    return curr;
}

BiTreeNode *DeleteRightTree(BiTreeNode *curr)       //右删除子树
{
    if(curr==NULL||curr->rightChild==NULL) return NULL;
    Destroy(&curr->rightChild);
    curr->rightChild=NULL;
    return curr;
}

【程序运行结果】
这里写图片描述

以上内容参考《数据结构——使用C语言（第五版）》，可能有些地方解释的不太清楚，欢迎指出

晓锋残月
关注
专栏目录
【数据结构】—二叉树遍历
四季轮换叶，一路招摇胜
05-01 1114
树是由n(n>=0)个结点所构成的有限集合。对于一颗非空树，其中有且仅有一个没有前驱的结点，这个结点就是【根节点】，其余结点有且仅有一个前驱，但可以有多个后继。今天讲解一下二叉树的三种遍历方法...
二叉树遍历之递归算法
热门推荐
__七把刀__
07-22 1万+
二叉树的遍历算法有多种，典型的有先序遍历、中序遍历、后序遍历以及层序遍历。而且这些遍历的递归算法较为简单，代码很少，容易实现，本文就是汇总二叉树遍历的递归算法，非递归算法将在下一篇文章中进行总结。本文中用到的二叉树实例如下： 3 / \ 9 20 / \ 15 7 二叉树定义和辅助函数如下： struct node {
二叉树的非递归遍历
csnd32068的博客
11-29 88
前面一篇介绍了二叉树的递归遍历操作http://blog.itpub.net/29876893/viewspace-1841619/，下面介绍二叉树的非递归遍历操作。 运用递归操作，很容易进行二叉树的遍历，结合上篇文章的介绍，...
二叉树后序遍历的非递归算法
最新发布
2301_80150315的博客
07-17 1037
二叉树后序遍历的非递归算法,严格按照上述伪代码的形式
二叉树遍历的递归算法
Henry's Blog
07-06 5707
【二叉树遍历的递归算法】  实现二叉树的先序、中序、后序遍历的递归算法，并对用”A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))”创建的二叉树进行测试。  1.头文件：btree.h，包含定义顺序表数据结构的代码、宏定义、要实现算法的函数的声明； #ifndef BTREE_H_INCLUDED #define BTREE_H_INCLUDED #defi
【二叉树】（一）递归遍历算法
qq_41959920的博客
07-13 3033
前言 二叉树的遍历算法是二叉树最基础的算法，没有之一。 二叉树的遍历算法主要有4种：先序遍历，中序遍历，后续遍历和层次遍历，其中第1-3个属于深度优先遍历，第4个属于广度优先遍历。 对二叉树的3种深度优先遍历算法的学习有三个层次： （一）精通遍历算法的递归实现； （二）精通遍历算法的基于栈结构的迭代实现； （三）精通遍历算法的统一风格的递归实现。 我们希望读者至少可以掌握前两个层次。 本文讲解递归实现的深度优先遍历算法，使用C++和Python3分别进行演示。 一、二叉树节点的定义 现在
二叉树遍历——递归算法
flystar27的博客
08-18 592
前序遍历：根 左 右 public static void preOrder(TreeNode root) { if(root == null) { return ; } //根 左 右 //第一次成为栈顶元素时打印 System.out.println(root.val); preOrder(root.left); preOrder(root.right); } 中序遍历：左 根 右 public static void midpreOrder(TreeNode
二叉树的层序遍历，直接打印+分层打印，递归和非递归法
曹健的博客
09-30 627
队列的性质：先进先出。 使用队列，将层序遍历结果保存到数组中： /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ class Solution { public int[] levelOrder(T
二叉树的层次遍历（非递归）
qq_44307686的博客
04-02 1044
#include<stdio.h> #include<stdlib.h> #define max 100 typedef struct Tree { char data; struct Tree *lchild; struct Tree *rchild; int ltag,rtag; }*tree ,Tree; typedef struct queue{ tree data[max]; int fount,real; }*queue.
二叉树的建立、先中后遍历以及层次遍历，交换左右子树，凹入打印二叉树，删除结点
04-12
根据给定文件的信息，本文将详细介绍二叉树的建立、先序、中序、后序以及层次遍历方法，左右子树的交换操作，以及如何实现凹入打印二叉树和删除节点等知识点。 ### 一、二叉树的建立 在给定的代码片段中，`bintree...
二叉树的遍历以及将二叉树倒置90°打印输入（递归）
zhouren1314的专栏
10-18 1536
class Tree{ public static void main(String args[]){ // 叶子节点 TreeModels t15=new TreeModels(null,null,15); TreeModels t14=new TreeModels(null,null,14); TreeModels t13=new TreeModels(null,nu
二叉树的建立及遍历
06-05
- 编写一个函数 `PostorderTraversal`，递归遍历整棵树，并输出后序遍历序列。 4. **凹入法输出二叉树**： - 凹入法（也称为层次遍历或水平遍历）按照从上到下、从左到右的顺序输出每一层的节点，同一层的节点...
算法 二叉树 凹入法家谱
12-21
在“凹入法家谱”中，二叉树被用来模拟家族关系。通常，家谱的构建可以采用以下方式：父节点作为根，其儿子作为左子节点，女儿作为右子节点。这样，每个节点都代表一个家庭成员，而父子关系通过树的链接清晰地表示...
二叉树递归遍历
zzyczzyc的博客
01-01 789
二叉树遍历 先序遍历：根左右 结果：ABCDEFGH 中序遍历：左根右 结果：BDCEAFHG 后续遍历：左右根 结果：DECBHGFA 代码 在这里插入代码片
非递归二叉树层次遍历算法
weixin_30535167的博客
10-16 74
基本思路： （1）若树节点非空，则入队。 （2）把对头的左右节点入队（非空），出队（并输出结果） （3）重复步骤（2）直到对为空 void LayerTraverse(BinTree BT){ Queue Q; BinTree p=BT; if(p!=NULL){ EnQueue(Q,p); } while(!IsEm...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值