二叉树3种遍历算法递归与非递归实现详解

最新推荐文章于 2024-10-10 15:26:55 发布
最新推荐文章于 2024-10-10 15:26:55 发布
阅读量1.2w 收藏 123
点赞数 20
分类专栏： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33883389/article/details/81879891
版权

 

一, 二叉树先序遍历的实现

  1.     递归实现
void PreOrderTraverse(BiTree T)
{


    if( T )
    {
        VisitF(T->data);//访问根节点
        PreOrderTraverse(T->lchild);//递归左子树
        PreOrderTraverse(T->rchild);//递归右子树
    }
}

    2.   非递归实现

思路： 

  1. 判断栈是否为空或子树为空
  2. 若不为空，就访问左孩子并将其入栈，直至左孩子为空
  3. 若左孩子为空，就出栈，然后访问右孩子，入栈，就这样不断的循环。

 

void PreOrderTraverse_Nonrecursion(BiTree T)
{
    LiStack  S ;
    BiTree  p ;
    S = NULL ;
    p = T ;

    InitStack(S) ;

    if(NULL == p)
    {
        printf("树为空！\n") ;
        return ;
    }

    while(p || !StackEmpty(S))
    {
        if(p)
        {
            Push(S, p) ;
            VisitF(p->data);
            p = p->lchild ;
        }
        else
        {
            Pop(S, p) ;
            p = p->rchild ;
        }
    }

    free(S) ;
}

 

 

 

二,  二叉树中序遍历的实现

 

  1.     递归实现
/*
    中序遍历二叉树
*/
void InOrderTraverse(BiTree T)
{

    if( T )
    {
        InOrderTraverse(T->lchild);
        VisitF(T->data);
        InOrderTraverse(T->rchild);
    }
}

      2.    非递归实现

思路：思路基本和先序差不多，只是输出数据的时候不一样

  1. 判断栈和树是否为空，

  2. 若不，则判断树是否为空，

  3. 不为继续将左子树进栈，若为空，则出栈，输出数据，然后访问右子树。

 

void InOrderTraverse_Nonrecursion(BiTree T)
{
    LiStack  S ;
    BiTree  p ;
    S = NULL ;
    p = T ;

    InitStack(S) ;

    if(NULL == p)
    {
        printf("树为空！\n") ;
        return ;
    }

    while(p || !StackEmpty(S))
    {
        if(p)
        {
            Push(S, p) ;

            p = p->lchild ;
        }
        else
        {
            Pop(S, p) ;
            VisitF(p->data);
            p = p->rchild ;
        }
    }

    free(S) ;
}

 

 

三,  二叉树中序遍历的实现

  1.  递归实现

 

/*
    后续遍历二叉树
*/
void PostOrderTraverse(BiTree T)
{

    if( T )
    {
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        VisitF(T->data);
    }
}

 2. 非递归实现

思路 ：实现有多多种方法，有两个栈，或加标志位实现，但是我觉得如下实现最容易懂

       要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。

 

void PostOrderTraverse_Nonrecursion(BiTree T)
{
    LiStack  S ;
    BiTree  cur, pre ;
    S = NULL ;
    InitStack(S) ;
    if(NULL == T)
    {
        printf("树为空！\n") ;
        return ;
    }

    pre = NULL ;
    cur = NULL ;
    Push(S,T) ;
    while(!StackEmpty(S))
    {
        cur = NULL ;
        GetTop(S,cur) ;
        if((cur->lchild == NULL && cur->rchild == NULL) || (pre != NULL && (pre == cur->lchild ||pre == cur->rchild)))
        {
            VisitF(cur->data);
            pre = cur ;
            Pop(S,cur) ;
        }
        else
        {
            if(cur->rchild != NULL)
            {
                Push(S,cur->rchild) ;
            }
            if(cur->lchild != NULL)
            {
                Push(S,cur->lchild) ;
            }
        }
    }
    free(S) ;
}

 

如下是完整代码：

 

#include<stdio.h>
#include<stdlib.h>

#define OK 1
#define ERROR -1

typedef char TElemType;

typedef int Status;

typedef struct BiTNode
{

    TElemType data;
    struct BiTNode *lchild,*rchild;

} BiTNode,*BiTree;


typedef BiTNode * StackElemType;

typedef struct LinkNode    //栈的节点
{
    StackElemType data ;
    LinkNode * next ;
} LinkNode,*LiStack;

typedef BiTNode * QueueElemType ;     //定义队列包含的数据类型

typedef struct QNode     //定义队列节点
{
    QueueElemType  data ;
    struct QNode * next ;
} QNode,*QueuePtr;

typedef struct
{
    QueuePtr fronts;
    QueuePtr rears;
} LinkQueue;



Status creatBiTree(BiTree &T);

void Visit(char ch,int level);

void PreOrderTraverse(BiTree T,int level);

void InOrderTraverse(BiTree T,int level);

void PostOrderTraverse(BiTree T,int level);

Status  InitStack(LiStack &S);

void Push(LiStack &S, StackElemType data);

void Pop(LiStack & S, StackElemType &data);

int StackEmpty(LiStack  &S);

int GetTop(LiStack &S, StackElemType & data);

Status InitQueue(LinkQueue &Q);

Status EnQueue(LinkQueue &Q, QueueElemType data);

Status DeQueue(LinkQueue &Q, QueueElemType & data);

int QueueEmpty(LinkQueue Q);

void PreOrderTraverse_Nonrecursion(BiTree T);

void InOrderTraverse_Nonrecursion(BiTree T);

void PostOrderTraverse_Nonrecursion(BiTree T);



/*********************************************************************/
/*****************************栈的方法********************************/
//栈的函数定义
Status  InitStack(LiStack &S)
{
    S = (LinkNode *)malloc(sizeof(LinkNode)) ;
    if(NULL == S)
    {
        printf("内存不足，不能分配栈！\n") ;
        exit(0) ;
    }

    S->next = NULL ;
}

void Push(LiStack &S, StackElemType data)
{
    LiStack q ;
    q = (LinkNode *)malloc(sizeof(LinkNode)) ;
    if(NULL == q)
    {
        printf("内存不足，不能分配栈！\n") ;
        exit(0) ;
    }

    /*
        插入顺序相当于头插法.
    */
    q->data = data ;
    q->next = S->next ;
    S->next = q ;
}

void Pop(LiStack & S, StackElemType &data)
{
    LiStack  q;
    if(NULL == S->next)
    {
        printf("栈为空，无返回值！\n") ;
    }

    q = S->next ;
    data = q->data ;
    S->next = q->next ;
    free(q) ;
}


int StackEmpty(LiStack  &S)
{
    if(NULL == S->next)
    {
        return(1) ;
    }

    return(0) ;
}

int GetTop(LiStack &S, StackElemType & data)
{
    if(NULL != S->next)
    {
        data = S->next->data ;
        return(1) ;
    }
    else
    {
        //data = NULL ;
        return(0) ;
    }
}

/*********************************************************************/




/*****************************队列的方法******************************/


//队列函数的定义
Status InitQueue(LinkQueue &Q)
{
    Q.fronts = Q.rears = (QNode *)malloc(sizeof(QNode)) ;
    if(NULL == Q.fronts)
    {
        printf("内存不足！\n") ;
        return ERROR;
    }

    Q.fronts->next = NULL;

}

Status EnQueue(LinkQueue &Q, QueueElemType data)
{
    QueuePtr q ;
    q = (QNode*)malloc(sizeof(QNode));

    if(NULL == q)
    {
        printf("内存不足！\n") ;
        return ERROR;
    }

    //构造q
    q->data = data ;
    q->next = NULL;


    q->next = Q.rears->next ;
    Q.rears = q ;

    return OK;
}

Status DeQueue(LinkQueue &Q, QueueElemType & data)
{
    QueuePtr  p ;
    if(Q.fronts == Q.rears)
    {
        printf("队列为空！\n") ;
        return ERROR ;
    }


    p = Q.fronts->next ;
    data = p->data ;


    Q.fronts->next = p->next ;
    if(Q.rears == p)
        Q.rears = Q.fronts ;

    free(p);

    return OK;
}

int QueueEmpty(LinkQueue Q)
{
    if(Q.fronts == Q.rears)
        return(1) ;
    else
        return(0) ;
}

/*********************************************************************/








/*
   先序创建二叉树
*/
Status creatBiTree(BiTree &T)
{
    char ch;

    scanf("%c",&ch);

    if('@' == ch)
    {
        T = NULL;
    }
    else
    {

        //申请失败
        if(!(T = (BiTNode*)malloc(sizeof(BiTNode))))
            return ERROR;

        T->data = ch;

        creatBiTree(T->lchild);
        creatBiTree(T->rchild);
    }



    return OK;
}

void VisitF(char ch)
{
    printf("%c  ",ch);
}

void Visit(char ch,int level)
{

    printf("%c 位于第 %d 层 \n",ch,level);

}


/*
    先序遍历二叉树
*/
void PreOrderTraverse(BiTree T,int level)
{



    if( T )
    {
        VisitF(T->data);
        PreOrderTraverse(T->lchild,++level);
        PreOrderTraverse(T->rchild,++level);
    }
}

void PreOrderTraverse_Nonrecursion(BiTree T)
{
    LiStack  S ;
    BiTree  p ;
    S = NULL ;
    p = T ;

    InitStack(S) ;

    if(NULL == p)
    {
        printf("树为空！\n") ;
        return ;
    }

    while(p || !StackEmpty(S))
    {
        if(p)
        {
            Push(S, p) ;
            VisitF(p->data);
            p = p->lchild ;
        }
        else
        {
            Pop(S, p) ;
            p = p->rchild ;
        }
    }

    free(S) ;
}


/*
    中序遍历二叉树
*/
void InOrderTraverse(BiTree T)
{

    if( T )
    {
        InOrderTraverse(T->lchild);
        VisitF(T->data);
        InOrderTraverse(T->rchild);
    }
}

void InOrderTraverse_Nonrecursion(BiTree T)
{
    LiStack  S ;
    BiTree  p ;
    S = NULL ;
    p = T ;

    InitStack(S) ;

    if(NULL == p)
    {
        printf("树为空！\n") ;
        return ;
    }

    while(p || !StackEmpty(S))
    {
        if(p)
        {
            Push(S, p) ;

            p = p->lchild ;
        }
        else
        {
            Pop(S, p) ;
            VisitF(p->data);
            p = p->rchild ;
        }
    }

    free(S) ;
}


/*
    后续遍历二叉树
*/
void PostOrderTraverse(BiTree T)
{

    if( T )
    {
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        VisitF(T->data);
    }
}

void PostOrderTraverse_Nonrecursion(BiTree T)
{
    LiStack  S ;
    BiTree  cur, pre ;
    S = NULL ;
    InitStack(S) ;
    if(NULL == T)
    {
        printf("树为空！\n") ;
        return ;
    }

    pre = NULL ;
    cur = NULL ;
    Push(S,T) ;
    while(!StackEmpty(S))
    {
        cur = NULL ;
        GetTop(S,cur) ;
        if((cur->lchild == NULL && cur->rchild == NULL) || (pre != NULL && (pre == cur->lchild ||pre == cur->rchild)))
        {
            VisitF(cur->data);
            pre = cur ;
            Pop(S,cur) ;
        }
        else
        {
            if(cur->rchild != NULL)
            {
                Push(S,cur->rchild) ;
            }
            if(cur->lchild != NULL)
            {
                Push(S,cur->lchild) ;
            }
        }
    }
    free(S) ;
}

int main()
{
    int level = 1;
    BiTree T = NULL;

    creatBiTree(T);

    printf("先序遍历二叉树，每个结点在第几行\n");
    PreOrderTraverse(T,level);

    printf("\n\n");
    printf("先序遍历二叉树,非递归算法\n");

    PreOrderTraverse_Nonrecursion(T);
    printf("\n\n\n");

    /***************************************************/


    printf("中序遍历二叉树\n");
    InOrderTraverse(T);

    printf("\n\n");
    printf("中序遍历二叉树,非递归算法\n");

    InOrderTraverse_Nonrecursion(T);
    printf("\n\n\n");

    /***************************************************/

    printf("后序遍历二叉树\n");
    PostOrderTraverse(T);

    printf("\n\n");
    printf("后序遍历二叉树,非递归算法\n");

    PostOrderTraverse_Nonrecursion(T);
    printf("\n\n\n");

    return 0;
}

 

年少却很低调
关注
专栏目录
Java二叉树前序遍历：递归+非递归实现，非递归详解
进击的Coder*的博客
04-13 1914
二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。 如下便是一棵二叉树： 二叉树的前序遍历： 1. 遍历根节点 2. 如果存在左子树，先序遍历左子树 3. 如果存在右子树，先序遍历右子树 二叉树结构定义： class TreeNode { int val; TreeNode left; TreeNode right; TreeNode() {} TreeNode(int val) { this.va
二叉树基本递归算法
m0_43425029的博客
08-12 3657
考研二叉树常见算法伪代码
详解二叉树的非递归遍历
最新发布
卷心菜是俺的博客
10-10 573
二叉树的非递归遍历使用栈或队列自身功能（先进后出或先进先出）来实现。对于非常深的树，递归可能导致栈溢出错误，因为每次递归调用都会占用栈空间。非递归遍历使用显式的栈或队列，可以更好地控制内存使用，避免这种问题。
二叉树的前序、中序、后序遍历（递归、非递归）实现
weixin_30654583的博客
06-24 1220
本文部分来源于CSDN兰亭风雨大牛的原创。链接为http://blog.csdn.net/ns_code/article/details/12977901 因为感觉大牛讲的很好，所以这里的文字讲解采用大牛的，大家可以直接看原创！代码部分是我自己的，leetcode代码，可在leetcode Accepted 二叉树是一种非常重要的数据结构，很多其他数据机构都是基于二叉树的基础演变过来的。二叉...
二叉树的遍历——递归和非递归
weixin_34293246的博客
10-31 213
                 二 叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是 递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用非递归的方法，就要采用栈去模拟实现。在三种遍历中， 前序和中序遍历的非递归算法都很容易实现，非递归后序遍历实现起来相对...
二叉树创建及遍历算法(递归及非递归)
IT旁观者
07-18 5464
//二叉树处理头文件 //包括二叉树的结构定义,二叉树的创建,遍历算法(递归及非递归), /* 作者：成晓旭 时间：2001年10月7日(18:49:38-20:00:00) 内容：完成二叉树创建,二叉树的前,中,后序遍历(递归) 时间：2001年10月7日(21:09:38-22:09:00) 内容：完成二叉树的前,中序遍历(非递归) 时间：2001年10月8日(10:09:38-1
二叉树操作 递归与非递归实现
挥剑踏苍穹的博客
05-10 249
采用递归的方式创建如下二叉树； 输入'#'代表当前子树结束。 #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct btn { struct btn * lchild, *rchild; char data; }btree, *BT;...
二叉树的非递归后序遍历算法实例详解
09-04
二叉树的后序遍历是一种重要的树遍历方式，尤其在非递归实现中，其逻辑相对复杂。本文将详细解析非递归后序遍历的算法实例，帮助理解其实现过程。 后序遍历的基本顺序是：左子树 -> 右子树 -> 根节点，但在非递归...
二叉树非递归遍历算法详解与实现
"二叉树非递归遍历算法实现" 在计算机科学中，二叉树是一种基础且重要的数据结构，通常用于实现各种算法和数据处理。二叉树的遍历是理解其结构和操作的关键步骤，主要有三种基本遍历方式：前序遍历、中序遍历和后序...
二叉树遍历算法详解：递归与非递归实现
"二叉树遍历C语言(递归-非递归)六种算法" 二叉树遍历是数据结构中一个重要的概念，它主要用于遍历或搜索二叉树的所有节点。在这个文档中，作者详细介绍了使用C语言实现二叉树的先序、中序和后序遍历的递归和非递归...
二叉树的递归算法
Studing In Depth
11-19 1289
很多数据结构的书中，都会详细的谈论很多数据结构，比如，线形表，树，图...而实际项目中，最常用的莫过于数组和链表，以及树（最多的还是二叉树），但是这些代码中多以伪代码居多，并且代码不完整，缺少注释。最近对数据结构复习了一阵，对二叉树做一个小结，以下是二叉树的递归代码。#include #include #include typedef struct BinaryTree{int key;struct BinaryTree *left;struct BinaryTree *right;}Node;Node *
二叉树非递归遍历
10-23
数据结构的代码实现，非递归算法，。
数据结构——二叉树的递归算法
qq_50675813的博客
11-27 3282
这里包含的递归算法有： 1.@[二叉树的先序创建]； 2. 二叉树的先序中序后序遍历； 3. 二叉树的销毁算法； 4. 双序遍历； 5. 求结点的个数； 6. 求结点值的和； 7. 求树的深度； 8. 求叶子结点的个数； 9. 求单分支结点的个数； 10. 交换结点的左右子树； 11. 寻找最小值结点； 12. 判断是否是相同的二叉树； 13. 判断是否是平衡二叉树； 14. 判断是对称二叉树； ...
二叉树的递归算法（先序，中序，后序）以及结点数，叶子结点数和深度，树的深度
qq_61059144的博客
04-22 3672
二叉树的递归算法（先序，中序，后序）以及结点数，叶子结点数和深度，树的深度
二叉树必备各种递归算法（求树的结点数，高度，叶子结点...）
热门推荐
weixin_43800761的博客
11-08 4万+
1、求二叉树中的节点个数 递归解法： （1）如果二叉树为空，节点个数为0 （2）如果二叉树不为空，二叉树节点个数 = 左子树节点个数 + 右子树节点个数 + 1 int NodeNum(BTNode * root) { if(root== NULL) // 递归出口 return 0; return NodeNum(root->lchild) + NodeNum(root->rchild) + 1; } 2、求二叉树的深度 递归解法： （1）如果二叉树为空，二叉
算法——（6.2）二叉树的递归
qq_57822260的博客
10-10 384
那么疑问来了，为什么上一题为什么不用回溯，我在上一题特地强调了，他的路径是作为参数传入进去，最简单的理解就是每个递归函数的每个路径参数都是一个list，而这一题list是一个全局变量，所有的递归公用一个。需要注意的是，尽管对象类型按引用传递，但实际上传递的是引用的副本，而不是引用本身。4.由次可见，当递归左右孩子的时候他们的返回值并没用，这主要是每次返回的是递归的这个节点，这个并没有用处，后面会遇到需要改变左右孩子节点，或者建立关系时候就需要返回值了。变量存储的是对象的引用，而不是对象本身。
树的遍历 递归和非递归版本
skysys的研究小屋
06-13 433
递归版本理解了递归就好了。不过递归是C语言学的，所以这里就不写了。直接po代码。 顺便所谓前序中序后序是指的根在前、中or后。 （华电的C语言课有点水…没有讲递归…我能怎么办呢…自己悟吧…我也不会讲…建议调试一遍就懂了，顺便了解一下递归的原理（实际上是借助了系统的调用栈）…） 前序遍历递归实现 void pre_traverse(BTree pTree) { if(pTree) ...
二叉树常见的递归算法
chenmoit的博客
12-09 484
//递归输出二叉树所有叶子结点 void DispLeaf(BTNode *b) { if(b!=null){ if(b->lchild==null&&b->rchild==null){ printf("%c",b->data); DispLeaf(b->lchild); DispLeaf(b->rchild); } } } //求值为x的结点的层次或者深度 int Level(BTNode *b,ElemType x,in
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值