对给定的一棵二叉树进行递归和非递归的遍历操作

最新推荐文章于 2024-07-24 20:22:36 发布
最新推荐文章于 2024-07-24 20:22:36 发布
阅读量1k 收藏 2
点赞数 1
分类专栏： 编程语言---C语言 文章标签： 二叉树 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45880844/article/details/105676554
版权

我们给出一棵确定的二叉树并进行递归和非递归的遍历比较

树的样子如下图所示：（下面的代码均是先递归后非递归）

给定的树的样子：
①头文件和结构体的定义：为了进行非递归时方便我们以链表的形式进行定义：

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

typedef struct BiTNode
{
    char data;
    struct BiTNode *Left,*Right;
}*BiTree;

两种方式的唯一区别就是有一个头文件不同，因为非递归是基于栈的特点进行的，所以多了一个头文件，其余可以说是一模一样的

#include <stdlib.h>
#include<stack>
#include<iostream>
using namespace std;

typedef struct node
{
    char data;
    struct node *lchild,*rchild; 
}*BTNode;

②创建一开始给出的那棵二叉树：

BiTree CreatBinTree()
{
    BiTree BT[9];
    int i;
    for(i=0;i<9;i++) 
	{
        BT[i]=(BiTree )malloc(sizeof(struct BiTNode));
        BT[i]->data=(char)(65+i);
    }
    BT[0]->Left=BT[1]; BT[0]->Right=BT[2]; 
    BT[1]->Left=BT[3]; BT[1]->Right=BT[5];
	BT[2]->Left=BT[6]; BT[2]->Right=BT[8]; 
	BT[3]->Left=NULL;  BT[3]->Right=NULL;
    BT[4]->Left=NULL;  BT[4]->Right=NULL; 
    BT[5]->Left=BT[4]; BT[5]->Right=NULL;
    BT[6]->Left=NULL;  BT[6]->Right=BT[7]; 
    BT[7]->Left=NULL;  BT[7]->Right=NULL;
    BT[8]->Left=NULL;  BT[8]->Right=NULL;
    
    return BT[0];
}

两种方式几乎是一模一样了，存在的区别也就只是因为一开始结构体定义时用的变量名不同了。

BTNode CreatBinTree()
{
    BTNode BT[9];
    int i;
    for(i=0;i<9;i++) 
	{
        BT[i]=(BTNode )malloc(sizeof(struct node));
        BT[i]->data=(char)(65+i);
    }
    BT[0]->lchild=BT[1]; BT[0]->rchild=BT[2]; 
    BT[1]->lchild=BT[3]; BT[1]->rchild=BT[5];
	BT[2]->lchild=BT[6]; BT[2]->rchild=BT[8];
	BT[3]->lchild=NULL;  BT[3]->rchild=NULL;
	BT[4]->lchild=NULL;  BT[4]->rchild=NULL;  
	BT[5]->lchild=BT[4]; BT[5]->rchild=NULL;
    BT[6]->lchild=NULL;  BT[6]->rchild=BT[7]; 
    BT[7]->lchild=NULL;  BT[7]->rchild=NULL;
    BT[8]->lchild=NULL;  BT[8]->rchild=NULL;
    
    return BT[0];
}

③介绍一下主函数：

int main()
{
    BiTree BT = CreatBinTree();
    
    printf("左根右 中序遍历:");    
    InorderTraversal(BT);    printf("\n");
    
    printf("根左右 先序遍历:");   
    PreorderTraversal(BT);   printf("\n");
    
    printf("左右根 后序遍历:");  
    PostorderTraversal(BT);  printf("\n");
    
    printf("层次遍历:"); 
    LevelorderTraversal(BT); printf("\n");
    return 0;
}

可以看出没什么区别的：

int main()
{
    BTNode BT = CreatBinTree();
    
    printf("左根右 中序遍历:");    
    InOrderWithoutRecursion1(BT);    printf("\n");
    
    printf("根左右 先序遍历:");   
    PreOrderWithoutRecursion1(BT);   printf("\n");
    
    printf("左右根 后序遍历:");  
    PostOrderWithoutRecursion(BT);   printf("\n");
    
    printf("层次遍历:"); 
    LevelorderTraversal(BT);         printf("\n");
    return 0;
}

④前序遍历：

void PreorderTraversal( BiTree BT )
{
	if(BT)
	{
        printf(" %c",BT->data);
        PreorderTraversal(BT->Left);
        PreorderTraversal(BT->Right);
    }
}

传入的参数是一种类型的，前序遍历是根左右的顺序进行的，所以非递归时，在找到左子树最下边之前遇到的根节点要依次输出，然后再访问根节点的右子树。输出一个根节点，就把这个根节点更新为当前节点的左子树（也是一个根节点）即可。

void PreOrderWithoutRecursion1(BTNode root)
{
    if (root == NULL)
        return;
    BTNode p = root;
    stack<BTNode> s;
    while (!s.empty() || p)//栈不空或者p不空
    {
        while (p!=NULL)
        {
            cout << ' ' << p->data;
            s.push(p);
            p = p->lchild;
        }
        if (!s.empty())
        {
            p = s.top();
            s.pop();
            p = p->rchild;
        }
    }
}

⑤中序遍历：

void InorderTraversal( BiTree BT )
{
	if(BT!=NULL)
	{
		InorderTraversal(BT->Left);
		printf(" %c",BT->data);
		InorderTraversal(BT->Right);
	}
}

中序遍历（左根右）和前序遍历区别就是在遇到根节点是我们先进行存储而不是先输出，在遇到左子树最下边之后，取出栈顶元素，并输出，然后把结点更新为当前节点的右子树。

void InOrderWithoutRecursion1(BTNode root)
{
    if (root == NULL)
        return;
    stack<BTNode> s;
    while (!s.empty() || root)//栈不空或者p不空 
    {
        while (root!=NULL)
        {
            s.push(root);
            root = root->lchild;
        }
        if (!s.empty())
        {
            root = s.top();
            s.pop();
            cout << ' '<< root->data;
            root = root->rchild;
        }
    }
}

⑥后序遍历：

void PostorderTraversal( BiTree BT )
{
	if(BT)
	{
        PostorderTraversal(BT->Left);
        PostorderTraversal(BT->Right);
        printf(" %c",BT->data);
    }

}

后序遍历比上面两种稍微麻烦一点，因为顺序是左右根，所以在输出根节点时必须是在没有右子树或者右子树已经输出过之后才可以。所以这里我们用两个变量，一个用来表示当前访问结点，一个用来指示上次访问节点。
###如果是没有右子树或是右子树已经被访问过了，那么我们就输出根节点的数据域。
###如果不是，那么就需要把当前的根节点存储一下，然后去访问右子树。也就是之前删除了的栈顶元素再次存储起来。

void PostOrderWithoutRecursion(BTNode root)
{
    if (root == NULL)
        return;
        
    stack<BTNode> s;
    BTNode pCur, pLastVisit;
    pCur = root;
    pLastVisit = NULL;
    
    while (pCur)
    {
        s.push(pCur);
        pCur = pCur->lchild;
    }
  
    while (!s.empty())
    {
        pCur = s.top();
        s.pop();
        if (pCur->rchild == NULL || 
        pCur->rchild == pLastVisit)
        {
            cout << ' ' << pCur->data;
            pLastVisit = pCur;
        }
        else
        {
            s.push(pCur);
            pCur = pCur->rchild;
            while (pCur)
            {
                s.push(pCur);
                pCur = pCur->lchild;
            }
        }
    }
    cout << endl;
}

⑦层次遍历：

void LevelorderTraversal( BiTree BT )
{
	BiTree q[100];
    BiTree p;
    int head=0,tail=0;
    if(!BT) return;
    if(BT)
	{
        q[tail++]=BT; 
        while(tail!=head)
		{
            p=q[head++];
            printf(" %c",p->data);
            if(p->Left)     q[tail++]=p->Left;
            if(p->Right)    q[tail++]=p->Right;
        } 
    }
}

一模一样，层次遍历主观图中最好理解，这里我们设置两个变量，一个用来掌管输出，一个用来不断地访问结点。两个变量的增长速度不一样大，所以直到两者相等时我们结束输出即可。

void LevelorderTraversal( BTNode BT )
{
	BTNode q[100];
    BTNode p;
    int head=0,tail=0;
    if(!BT) return;
    if(BT)
	{
        q[tail++]=BT; 
        while(tail!=head)
		{
            p=q[head++];
            printf(" %c",p->data);
            if(p->lchild)     q[tail++]=p->lchild;
            if(p->rchild)    q[tail++]=p->rchild;
        } 
    }
}

⑧给出最后输出结果：
递归操作：
可以看出两者运行的时间还是有很大差距的，事实上递归的效率要更高一些。
在这里插入图片描述
⑨给出两种方式完整的代码：

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

typedef struct BiTNode
{
    char data;
    struct BiTNode *Left,*Right;
}*BiTree;

BiTree CreatBinTree()
{
    BiTree BT[9];
    int i;
    for(i=0;i<9;i++) 
	{
        BT[i]=(BiTree )malloc(sizeof(struct BiTNode));
        BT[i]->data=(char)(65+i);
    }
    BT[0]->Left=BT[1]; BT[0]->Right=BT[2]; BT[1]->Left=BT[3]; BT[1]->Right=BT[5];
	BT[2]->Left=BT[6]; BT[2]->Right=BT[8]; BT[3]->Left=NULL;  BT[3]->Right=NULL;
    BT[4]->Left=NULL;  BT[4]->Right=NULL;  BT[5]->Left=BT[4]; BT[5]->Right=NULL;
    BT[6]->Left=NULL;  BT[6]->Right=BT[7]; BT[7]->Left=NULL;  BT[7]->Right=NULL;
    BT[8]->Left=NULL;  BT[8]->Right=NULL;
    return BT[0];
}

void InorderTraversal( BiTree BT );
void PreorderTraversal( BiTree BT );
void PostorderTraversal( BiTree BT );
void LevelorderTraversal( BiTree BT );

int main()
{
    BiTree BT = CreatBinTree();
    
    printf("左根右 中序遍历:");    InorderTraversal(BT);    printf("\n");
    printf("根左右 先序遍历:");   PreorderTraversal(BT);   printf("\n");
    printf("左右根 后序遍历:");  PostorderTraversal(BT);  printf("\n");
    printf("层次遍历:"); LevelorderTraversal(BT); printf("\n");
    return 0;
}

void InorderTraversal( BiTree BT )
{
	if(BT!=NULL)
	{
		InorderTraversal(BT->Left);
		printf(" %c",BT->data);
		InorderTraversal(BT->Right);
	}
}
void PreorderTraversal( BiTree BT )
{
	if(BT)
	{
        printf(" %c",BT->data);
        PreorderTraversal(BT->Left);
        PreorderTraversal(BT->Right);
    }
}
void PostorderTraversal( BiTree BT )
{
	if(BT)
	{
        PostorderTraversal(BT->Left);
        PostorderTraversal(BT->Right);
        printf(" %c",BT->data);
    }

}
void LevelorderTraversal( BiTree BT )
{
	BiTree q[100];
    BiTree p;
    int head=0,tail=0;
    if(!BT) return;
    if(BT)
	{
        q[tail++]=BT; 
        while(tail!=head)
		{
            p=q[head++];
            printf(" %c",p->data);
            if(p->Left)     q[tail++]=p->Left;
            if(p->Right)    q[tail++]=p->Right;
        } 
    }
}


#include <stdlib.h>
#include<stack>
#include<iostream>
using namespace std;

typedef struct node
{
    char data;
    struct node *lchild,*rchild; 
}*BTNode;

BTNode CreatBinTree()
{
    BTNode BT[9];
    int i;
    for(i=0;i<9;i++) 
	{
        BT[i]=(BTNode )malloc(sizeof(struct node));
        BT[i]->data=(char)(65+i);
    }
    BT[0]->lchild=BT[1]; BT[0]->rchild=BT[2]; BT[1]->lchild=BT[3]; BT[1]->rchild=BT[5];
	BT[2]->lchild=BT[6]; BT[2]->rchild=BT[8]; BT[3]->lchild=NULL;  BT[3]->rchild=NULL;
	BT[4]->lchild=NULL;  BT[4]->rchild=NULL;  BT[5]->lchild=BT[4]; BT[5]->rchild=NULL;
    BT[6]->lchild=NULL;  BT[6]->rchild=BT[7]; BT[7]->lchild=NULL;  BT[7]->rchild=NULL;
    BT[8]->lchild=NULL;  BT[8]->rchild=NULL;
    return BT[0];
}
//中序遍历 
void InOrderWithoutRecursion1(BTNode root)
{
    if (root == NULL)
        return;
    stack<BTNode> s;
    while (!s.empty() || root)//栈不空或者p不空 
    {
        while (root!=NULL)
        {
            s.push(root);
            root = root->lchild;
        }
        if (!s.empty())
        {
            root = s.top();
            s.pop();
            cout << ' '<< root->data;
            root = root->rchild;
        }
    }
}
//前序遍历： 
void PreOrderWithoutRecursion1(BTNode root)
{
    if (root == NULL)
        return;
    BTNode p = root;
    stack<BTNode> s;
    while (!s.empty() || p)//栈不空或者p不空
    {
        while (p!=NULL)
        {
            cout << ' ' << p->data;
            s.push(p);
            p = p->lchild;
        }
        if (!s.empty())
        {
            p = s.top();
            s.pop();
            p = p->rchild;
        }
    }
}   
//后序遍历
void PostOrderWithoutRecursion(BTNode root)
{
    if (root == NULL)
        return;
        
    stack<BTNode> s;
    BTNode pCur, pLastVisit;
    pCur = root;
    pLastVisit = NULL;
    
    while (pCur)
    {
        s.push(pCur);
        pCur = pCur->lchild;
    }
  
    while (!s.empty())
    {
        pCur = s.top();
        s.pop();
        if (pCur->rchild == NULL || pCur->rchild == pLastVisit)
        {
            cout << ' ' << pCur->data;
            pLastVisit = pCur;
        }
        else
        {
            s.push(pCur);
            pCur = pCur->rchild;
            while (pCur)
            {
                s.push(pCur);
                pCur = pCur->lchild;
            }
        }
    }
    cout << endl;
}
void LevelorderTraversal( BTNode BT )
{
	BTNode q[100];
    BTNode p;
    int head=0,tail=0;
    if(!BT) return;
    if(BT)
	{
        q[tail++]=BT; 
        while(tail!=head)
		{
            p=q[head++];
            printf(" %c",p->data);
            if(p->lchild)     q[tail++]=p->lchild;
            if(p->rchild)    q[tail++]=p->rchild;
        } 
    }
}
int main()
{
    BTNode BT = CreatBinTree();
    
    printf("左根右 中序遍历:");    InOrderWithoutRecursion1(BT);    printf("\n");
    printf("根左右 先序遍历:");   PreOrderWithoutRecursion1(BT);   printf("\n");
    printf("左右根 后序遍历:");  PostOrderWithoutRecursion(BT);  printf("\n");
    printf("层次遍历:"); LevelorderTraversal(BT); printf("\n");
    return 0;
}
写在最后：如果大家还不懂，可以搜我公共号：菜菜的学习日记，里面有更详细的解释。
一只天蝎
关注
专栏目录
二叉树的基本操作实现（递归和非递归）
zhuohaiyy的博客
10-12 733
二叉树：二叉树是一棵特殊的树，二叉树每个节点最多有两个孩子结点，分别称为左孩子和右孩子。 满二叉树:高度为N的满二叉树有2^N- 1个节点的二叉树。完全二叉树: 若设二叉树的深度为h，除第h 层外，其它各层(1～h-1) 的结点数都达到最大个数，第h 层所有的结点都连续集中在最左边，这就是完全二叉树二叉树的基本操作：构造二叉树，前序遍历，中序遍历，后序遍历，求树的叶子结点，树的深度，树中第K层的结点
二叉树递归和非递归遍历
一个不知名码农的专栏
07-08 611
二叉树递归和非递归遍历 源码： #include<queue> #include<stack> #include<vector> #include<iostream> using namespace std; //假设空节点的值为-1 //const int arrrlens = 18; //char arr[arrrlens] = { 'A', ...
[二叉树]分别用递归和非递归方式实现二叉树先序、中序和后序遍历
ltcz99的博客
11-13 582
题目：用递归和非递归两种方式，分别按照二叉树先序、中序和后序打印所有的节点。我们约定先遍历顺序为根、左、右；中序遍历顺序为左、根、右；后序遍历为左、右、根。 前提知识： 递归的遍历： 树的遍历与递归 最近做一个统计工作，需要遍历一些文件，一个文件夹下面有很多层的小文件，如何算出这个文件夹下面有多少文件？相信很多人第一时间都能想到递归遍历，这是最直接，最简单的办法。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧...
影视剪辑（自媒体）工具下载地址
最新发布
zyg的博客
07-24 2274
自媒体网址收藏
数据结构二叉树前序遍历递归和非递归算法
m0_63142359的博客
11-19 2186
数据结构二叉树前序遍历递归和非递归算法。
二叉树的遍历的递归与非递归实现
a760352276的博客
10-27 1376
二叉树的遍历问题1.递归序2.递归方法遍历二叉树3.非递归方法遍历前序遍历后序遍历：中序遍历：小结： 1.递归序 抛开二叉树的遍历。我们来单看一个普通的递归函数： public static void DiGui(Tree node){ if(node == null){ return; } /* 节点第一次到达DiGui函数体 */ System.out.println("first time:" + node.val
用非递归的方式遍历二叉树
baymin_dly的博客
08-07 844
1、前序遍历的非递归实现     根据先序遍历的顺序，先访问根节点，再访问左子树，后访问右子树，而对于每个子树来说，又按照同样的访问顺序进行遍历，非递归的实现思路如下： 对于任一节点P， 1）输出节点P，然后将其入栈，再看P的左孩子是否为空； 2）若P的左孩子不为空，则置P的左孩子为当前节点，重复1）的操作； 3）若P的左孩子为空，则将栈顶节点出栈，但不输出，并将出栈节点的右孩子置
二叉树的递归、非递归遍历
weixin_43201538的博客
12-26 633
介绍： 本文简单的介绍一下二叉树的前、中、后序遍历的递归和非递归的实现方法。最后再来看看一道折纸问题来加深对遍历的理解。 先简单说说概念： 顾名思义： 前序遍历：二叉树结点的访问顺序为 ： 根节点、左节点、右节点。 中序遍历：二叉树结点的访问顺序为 ： 左节点、根节点、右节点。 后序遍历：二叉树结点的访问顺序为 ： 左节点、右节点、根节点。 递归和非递归的关系。理论上来说可以用递归方法实现的，也可...
二叉树非递归遍历
10-23
数据结构的代码实现，非递归算法，。
给定一棵二叉树，采用递归和非递归的方法实现二叉树的非递归先序遍历和后序遍历
06-28
1. 递归遍历左子树 2. 递归遍历右子树 3. 访问根节点 非递归后序遍历： 1. 将根节点入栈 2. 初始化一个辅助栈 3. 当栈不为空时，弹出栈顶元素并压入辅助栈 4. 如果该节点有左子树，将左子树入栈 5. 如果该节点有右...
C#非递归先序遍历二叉树实例
09-03
在C#编程中，二叉树是一种常见的数据结构，它由节点组成，每个节点可以有零个、一个或两个子节点。...在实际应用中，非递归遍历不仅可以节省内存，还可以提高程序的运行效率，因为控制流更加直观，易于理解和调试。
四种根据给定遍历序列构造二叉树总结（JAVA递归和非递归版）
12-21
二叉树的遍历顺序及方法可参考之前写过的二叉树的遍历（JAVA递归和非递归版）这里解决的是如何根据给定的遍历序列构造二叉树的问题。 根据前序与中序遍历序列构造二叉树 该问题中，会给出二叉树的前序与中序的遍历...
二叉树建立 二叉树遍历 二叉树 递归 非递归 先序 中序 后序 层序遍历
安徽小亚哥哥的博客
05-31 468
二叉树递归创建：本质上和二叉树递归遍历一样，但是当需要知道何时节点孩子为空，因此这里用#做分隔符。先序建立：先给当前节点分配数据，然后创建左子树，然后创建又子树。 public Node createTree(){//递归先序创建树 if(index &gt;= input.length){ return null; } if(input[index]=='#'){ ind...
Java工程师面试1000题224-使用递归和非递归实现二叉树的前、中、后序遍历
于占胜的博客
04-12 234
224、使用递归和非递归实现二叉树的前、中、后序遍历 使用递归来实现二叉树的前、中、后序遍历比较简单，直接给出代码，我们重点讨论非递归的实现。 class Node { public int value; public Node left; public Node right; public Node() { } public Node(i...
二叉树的前序、中序、后序遍历（递归、非递归）实现
weixin_30654583的博客
06-24 1205
本文部分来源于CSDN兰亭风雨大牛的原创。链接为http://blog.csdn.net/ns_code/article/details/12977901 因为感觉大牛讲的很好，所以这里的文字讲解采用大牛的，大家可以直接看原创！代码部分是我自己的，leetcode代码，可在leetcode Accepted 二叉树是一种非常重要的数据结构，很多其他数据机构都是基于二叉树的基础演变过来的。二叉...
二叉树的遍历——递归和非递归
weixin_34293246的博客
10-31 194
                 二 叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是 递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用非递归的方法，就要采用栈去模拟实现。在三种遍历中， 前序和中序遍历的非递归算法都很容易实现，非递归后序遍历实现起来相对...
leetcode 145 二叉树的后序遍历（非递归）
Luyoom的博客
01-16 425
二叉树？后序遍历！ 题目： 给定一个二叉树，返回它的 后序 遍历。 例子： 输入: [1,null,2,3] 1 \ 2 / 3 输出: [3,2,1] 题目分析 后续遍历 右子树 根节点 左子树 递归三行解决 不使用递归？ 栈 保存节点信息 即可 解题思路 变量 作用 stack < Treenode * > s 保存节点信息 TreeNode * ...
数据结构 递归和非递归方式实现二叉树先序、中序和后序遍历
aotangai1607的博客
02-15 270
　　二叉树的先序遍历顺序是根、左、右；中序遍历顺序是左、根、右；后序遍历顺序是左、右、根。 　　递归方式实现如下： 1 public class TreeNode { 2 private int value; 3 private TreeNode left, right; 4 5 public TreeNode(int data...
二叉树（3）----后序遍历，递归和非递归方式
录事参军
12-14 2334
1、二叉树定义 typedef struct BTreeNodeElement_t_ { void *data; } BTreeNodeElement_t; typedef struct BTreeNode_t_ { BTreeNodeElement_t *m_pElemt; struct BTreeNode_t_ *m_pLeft; struct BTr
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一只天蝎

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值