数据结构--递归遍历二叉树的c语言实现（超详细注释/实验报告）

最新推荐文章于 2024-09-18 22:23:06 发布
最新推荐文章于 2024-09-18 22:23:06 发布
阅读量4.4k 收藏 69
点赞数 12
分类专栏： 数据结构 文章标签： 算法 数据结构 c语言 二叉树 树结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dream_of_grass/article/details/121585166
版权

数据结构–递归遍历二叉树的c语言实现（超详细注释/实验报告）

知识小回顾

二叉树的遍历是指按照一定规律对二叉树中的每个结点进行访问且仅访问一次。其中的访问可知计算二叉树中结点的数据信息，打印该结点的信息们也包括对结点进行任何其他操作。

实验题目

输出二叉树的遍历结果

实验目的

  1. 熟悉二叉树的结点的结构
  2. 采用二叉链表作为存储结构建立二叉树
  3. 采用递归算法对其进行遍历（先序、中序、后序）
  4. 将遍历结果输出
    在这里插入图片描述

实验要求

  1. 采用二叉链表作为存储结构建立二叉树
  2. 采用递归算法对其进行遍历（先序、中序、后序）
  3. 将遍历结果输出

实验内容和实验步骤

1.需求分析

用户输入二叉树的广义表形式，程序输出二叉树和遍历结果。

2. 概要设计

设计创建和输出二叉树的函数以及三种遍历的函数，然后再主函数中调用这几个函数来实现操作。

3. 详细设计

建立二叉树并输出二叉树的代码，之前写过了
创建并输出二叉树
下面来看看遍历的操作
因为采用了递归方法，故三种方式都差不多，只用改变一下visit的顺序即可。

//中序遍历
void Inorder(BiTree *bt)
{
    if(bt!=NULL)
    {
        Inorder(bt->lc);
        printf("%c ",bt->data);
        Inorder(bt->rc);
    }
}

//先序遍历
void Preorder(BiTree *bt)
{
    if(bt!=NULL)
    {
        printf("%c ",bt->data);
        Preorder(bt->lc);
        Preorder(bt->rc);
    }
}

//后序遍历
void Postorder(BiTree *bt)
{
    if(bt!=NULL)
    {
        Postorder(bt->lc);
        Postorder(bt->rc);
        printf("%c ",bt->data);
    }
}

主函数部分，把程序功能打印出来，并对用户做一个引导。
在这里插入图片描述

int main()//(A(B(D,),C(,E)))   (A(B(D,E),C(F,G)))  ((((A),B)),(((),D),(E,F)))这个不是树
//来个波兰表达式的例子 (-(+(a,*(b,c)),/(d,e)))
{
    BiTree *bt;
    char *gyb,str[MAXSIZE];
    int j=1;
    printf("-------------------------------------------------------");
    printf("\n            程序功能");
    printf("\n 1.将按照输入的二叉广义表表示字符串 ");
    printf("\n · 生成对应的二叉树链式结构。");
    printf("\n 2.输出二叉树的凹入法表示形式。");
    printf("\n · G--根 L--左孩子 R--右孩子");
    printf("\n 3.树状打印二叉树。");
    printf("\n · 逆时针旋转90度显示二叉树");
    printf("\n 4.打印出先序、中序和后续遍历的结果。");
    printf("\n * 输入示例：(A(B(D,),C(,E)))或(-(+(a,*(b,c)),/(d,e)))");
    printf("\n-------------------------------------------------------\n");
    printf("请输入二叉树的广义表形式：\n");
    gyb=str;
    scanf("%s",str);
    bt =CreatBiTreepre(gyb);
    printf("二叉树建立成功！\n");
    printf("此二叉树的凹入法表示为：\n");
    OutBiTree(bt);
    printf("树状打印二叉树：\n");
    PrintTree(bt,1);
    printf("先序遍历序列为：\n");
    Preorder(bt);
    printf("\n中序遍历序列为：\n");
    Inorder(bt);
    printf("\n后序遍历序列为：\n");
    Postorder(bt);
    return 0;
}

在这里插入图片描述

4. 调试分析

遇到的问题及解决方法
  • 有了前面创建和输出二叉树做铺垫，实现递归的遍历算法还是很简单的。
算法的时空分析

设二叉树有n个结点，对每个结点都要进行一次入栈和出栈的操作，即入栈和出栈各执行n次，对结点的访问也是n次。这些二叉树递归遍历算法的时间复杂度为 O ( n ) O(n) O(n)。

实验结果

实验结果很不错，所有操作都能正常执行，用波兰表达式做例子得到了正确的输出。
这是上面分析的例子的程序给出的输出。

下面这个例子大家也可以看看。
在这里插入图片描述

实验总结

有了前面工作的铺垫，递归遍历就很简单了，多多重复，百炼成钢！

最后附上完整的代码

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 255
//定义二叉树的链式存储结构，有三个域：数据域，左孩子域，右孩子域
typedef struct BiNode
{
    char data;
    struct BiNode *lc;
    struct BiNode *rc;
}BiTree;

//以广义表的形式创建二叉树
BiTree *CreatBiTreepre(char *str)
{
    BiTree *bt,*stack[MAXSIZE],*p=NULL;
    int top=-1,k,j=0;
    char ch;
    bt=NULL;
    ch=str[j];
    while(ch!='\0')
    {
        switch(ch)
        {
        case '(':
            {
                top++;
                stack[top]=p;
                k=1;
                break;
            }
        case ')':
            {
                top--;
                break;
            }
        case ',':
            {
                k=2;
                break;
            }
        default:
            {
                p=(BiTree *)malloc(sizeof(BiTree));
                p->data=ch;
                p->lc=p->rc=NULL;
                if(bt==NULL)
                {
                    bt=p;
                }
                else
                {
                    switch(k)
                    {
                    case 1:
                        {
                            stack[top]->lc=p;
                            break;
                        }
                    case 2:
                        {
                            stack[top]->rc=p;
                            break;
                        }
                    }
                }
            }
        }
        j++;
        ch=str[j];
    }
    return bt;//链式存储只用知道一个，后面顺藤摸瓜就都知道了
}

//采用凹入法输出二叉树
void OutBiTree(BiTree *bt)
{
    BiTree *stack[MAXSIZE],*p;
    int feature[MAXSIZE][2],top,n,i,width=4;
    char type;
    if(bt!=NULL)
    {
        top=1;
        stack[top]=bt;
        feature[top][0]=width;
        feature[top][1]=2;
        while(top>0)
        {
            p=stack[top];
            n=feature[top][0];
            switch(feature[top][1])
            {
            case 0:
                {
                    type='l';
                    break;
                }
            case 1:
                {
                    type='R';
                    break;
                }
            case 2:
                {
                    type='G';
                    break;
                }
            }
            for(i=1;i<=n;i++)
                printf(" ");
            printf("%c(%c)\n",p->data,type);
            top--;
            if(p->lc!=NULL)
            {
                top++;
                stack[top]=p->lc;
                feature[top][0]=n+width;
                feature[top][1]=0;
            }
            if(p->rc!=NULL)
            {
                top++;
                stack[top]=p->rc;
                feature[top][0]=n+width;
                feature[top][1]=1;
            }

        }
    }
}

void PrintTree(BiTree *bt,int nLayer)
{
    if(bt==NULL)
        return ;
    PrintTree(bt->rc,nLayer+1);
    for(int i=0;i<nLayer;i++)
        printf("  ");
    printf("%c\n",bt->data);
    PrintTree(bt->lc,nLayer+1);
}

//中序遍历
void Inorder(BiTree *bt)
{
    if(bt!=NULL)
    {
        Inorder(bt->lc);
        printf("%c ",bt->data);
        Inorder(bt->rc);
    }
}

//先序遍历
void Preorder(BiTree *bt)
{
    if(bt!=NULL)
    {
        printf("%c ",bt->data);
        Preorder(bt->lc);
        Preorder(bt->rc);
    }
}

//后序遍历
void Postorder(BiTree *bt)
{
    if(bt!=NULL)
    {
        Postorder(bt->lc);
        Postorder(bt->rc);
        printf("%c ",bt->data);
    }
}

int main()//(A(B(D,),C(,E)))   (A(B(D,E),C(F,G)))  ((((A),B)),(((),D),(E,F)))这个不是树
//来个波兰表达式的例子 (-(+(a,*(b,c)),/(d,e)))
{
    BiTree *bt;
    char *gyb,str[MAXSIZE];
    int j=1;
    printf("-------------------------------------------------------");
    printf("\n            程序功能");
    printf("\n 1.将按照输入的二叉广义表表示字符串 ");
    printf("\n · 生成对应的二叉树链式结构。");
    printf("\n 2.输出二叉树的凹入法表示形式。");
    printf("\n · G--根 L--左孩子 R--右孩子");
    printf("\n 3.树状打印二叉树。");
    printf("\n · 逆时针旋转90度显示二叉树");
    printf("\n 4.打印出先序、中序和后续遍历的结果。");
    printf("\n * 输入示例：(A(B(D,),C(,E)))或(-(+(a,*(b,c)),/(d,e)))");
    printf("\n-------------------------------------------------------\n");
    printf("请输入二叉树的广义表形式：\n");
    gyb=str;
    scanf("%s",str);
    bt =CreatBiTreepre(gyb);
    printf("二叉树建立成功！\n");
    printf("此二叉树的凹入法表示为：\n");
    OutBiTree(bt);
    printf("树状打印二叉树：\n");
    PrintTree(bt,1);
    printf("先序遍历序列为：\n");
    Preorder(bt);
    printf("\n中序遍历序列为：\n");
    Inorder(bt);
    printf("\n后序遍历序列为：\n");
    Postorder(bt);
    return 0;
}
数据结构（廿五） -- C语言版 -- 图 - 图的遍历 -- 邻接矩阵 - 深度/广度优先遍历/搜索（DFS、BFS）
青椒*^_^*凤爪爪的博客
12-08 6530
图是一种非线性的数据结构，图的遍历指的是：从图中的某一顶点出发，沿着一些边访问图中所有的顶点，使得每个顶点都被访问且仅被访问一次。根据遍历路径的不同，通常有两种遍历图的方法：深度优先遍历(Depth First Search)和广度优先遍历(Breadth First Search)。它们对无向图和有向图都适用，图的遍历算法是求解图的连通性问题、拓扑排序和求关键路径等算法的基础。
数据结构（C语言）关于二叉树的递归遍历
AtomQQ_2022313691的博客
07-07 472
二叉树的遍历 先序遍历 ：−+A×BC÷DE-+A\times BC \div DE−+A×BC÷DE 中序遍历 ：A+B×C−D÷EA+B\times C-D\div EA+B×C−D÷E 后序遍历 ：ABC×+DE÷−ABC\times +DE\div-ABC×+DE÷− emmmm如果你看不懂的话，你可以先这样，首先将这个二叉树的左边补全！！！一定是左边，因为根据遍历顺序而来的！！！相信我 然后跟我的GIF图走一遍 先序遍历 中序遍历 后序遍历 找找规律，因为二叉树是一个嵌套的结构（比如
数据结构 --- c语言递归法遍历二叉树
weixin_60569662的博客
02-24 1189
二叉树的单一个体 - - -> 一个节点、两个指针，结构体的定义和双向链表类似 二叉树可以存任何类型的数据：这里选择存char类型数据 二叉树的结构体描述 #include <stdio.h> #include <stdlib.h> #include <assert.h> typedef struct Node { char data; //顶点数据 struct Node* LChild; //左子树的指针 struct No...
【数据结构】二叉树
最新发布
DerrictC的博客
09-18 1120
该算法从堆的根节点开始，通过比较和交换节点值，将根节点调整到其在堆中的正确位置，以确保堆的每个父节点的值都大于或等于其子节点的值（在最大堆中），或者小于或等于其子节点的值（在最小堆中）。我们常见的二叉树的结构叫逻辑结构如下图1，这是我们自己想象出来的二叉树的样子，但实际上二叉树并不是就像图中所示的那样，二叉树真正的结构，也叫物理结构，是像数组一样每个数据一行排开，如图2，图2所示及是实实在在。也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。如果二叉树为空，则退出；
【数据结构】遍历二叉树的方法（C语言）
xiangjunyes的博客
06-20 3035
文章目录二叉树遍历原理二叉树遍历方法前序遍历中序遍历中序遍历算法后序遍历后续遍历算法层序遍历二叉树遍历的性质 二叉树遍历原理 二叉树的遍历是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。 两个关键字：“访问”和“次序”。 访问其实是要根据实际的需要来确定具体做什么，比如对每个结点进行相关计算，输出打印等，它算作是一个抽象操作等。在这里我们可以简单的假设就是输出结点的数据信息。 二叉树的遍历次序不同于线性结构，最多也就是从头到尾，循环，双向等简单的遍历方式。树的结
二叉树遍历——递归链式（C语言实现）
qq_63580639的博客
10-27 2711
递归实现二叉树的前，中，后，层，序遍历
【数据结构】C语言递归实现二叉树遍历
weixin_43550839的博客
07-27 604
一.头文件 BTree.h #include <stdio.h> typedef char BTDataType; #define ENDTAG '#' typedef struct BinaryTreeNode { BTDataType _data; struct BinaryTreeNode* _left; struct BinaryTreeNode* _right; }BT...
数据结构实验报告6-树-二叉树的遍历算法-实验内容及要求.docx
07-06
根据给定文件的信息，我们可以详细地探讨一下关于二叉树的遍历算法这一主题，包括实验的目的、数据结构的设计、算法的设计以及输入/输出的设计等内容。 ### 实验目的 本次实验的主要目的是让学生深入理解并掌握...
数据结构（二叉树篇）------实现递归与非递归方法的二叉树先序、中序、后序遍历
weixin_44689331的博客
04-19 846
数据结构（二叉树篇）------实现递归与非递归方法的二叉树先序、中序、后序遍历，链栈的简单实现
c代码-非递归实现二叉树的创建并先序递归遍历
07-14
在IT领域，二叉树是一种基础且重要的数据结构，它由节点构成，每个节点最多有两个子节点，通常称为左子节点和右子节点。在本主题中，我们将深入探讨如何用C语言非递归地创建二叉树以及进行先序遍历。非递归方法在...
数据结构试验报告---二叉树的生成，遍历二叉树（递归前中后，非递归前中后）
qq_41529435的博客
01-29 915
上机实验习题 上机实验要求及规范 C程序设计具有比较强的理论性，同时也具有较强的可应用性和实践性。在上机实验是一个重要的教学环节。具体实习步骤如下： 1.问题分析与系统结构设计 充分地分析和理解问题本身，弄清要求做什么（而不是怎么做），限制条件是什么。按照以数据结构为中心的原则划分模块，搞清数据的逻辑结构（是线性表还是树、图？），确定数据的存储结构（是顺序结构还是链表结构？）。然后设计有关操作的函...
c语言递归遍历二叉树
10-22
递归遍历二叉树、c语言以及数据结构均要用到，我还会上传非递归的··
C例子：遍历二叉树
08-22
该程序是我写的博客“一起talk C栗子吧（第四十回：C语言实例--遍历二叉树）”的配套程序，共享给大家使用
【C语言】利用递归来实现二叉树的前，中，后序遍历以及补充一些与二叉树相关的操作
wzx0806的博客
07-18 616
1.前序遍历：（Preorder Traversal 亦称先序遍历）---访问根节点的操作发生在遍历其左右子树之前。2.（Inorder Traversal）----访问根节点的操作发生在遍历其左右子树之间。（Postorder Traversal）---访问根节点的操作发生在遍历其左右子树之后。由于被访问的节点必然是某子树的根，所以N(Node)，L(Left subtree) 和 R(Right subtree)又可以解释为根，根的左子树和根的右子树。
c语言实现二叉树的递归遍历
hou19975418的博客
01-17 1199
c语言实现二叉树递归遍历，首先用结构体给出结点类型，然后创建具体的结点变量，接着对结点进行连接。递归遍历的函数的内部主要是根节点的打印和左右子树的递归，前中后序的实现通过调整递归的顺序即可完成。
C语言实现二叉树的递归遍历与非递归遍历
热门推荐
cqnuztq的专栏
05-07 3万+
本文实现了对二叉树的递归遍历和非递归遍历，当然还包括了一些栈操作。           二叉树的遍历本质上其实就是入栈出栈的问题，递归算法简单且容易理解，但是效率始终是个问题。非递归算法可以清楚的知道每步实现的细节，但是乍一看不想递归算法那么好理解，各有各的好处吧。接下来根据下图讲讲树的遍历。           1、先序遍历：先序遍历是先输出根节点，再输出左子树，最后输出右子树。
C语言 二叉树的遍历（递归和非递归）
weixin_30648963的博客
01-22 148
#include <iostream> #include <cstdio> #include "biTree.h" #include "cstdlib" #define OVERFLOW -1 #include <stack> using namespace std; Status CreateBiTree( BiTree &T ) {...
[C语言]二叉树的递归遍历
renboyu010214的博客
04-05 221
遍历方法：无论哪种遍历方式，对每个节点的查看方式一般都遵循先左后右 二叉树的遍历方式 （D：DATA，L：LEFT，R：RIGHT） 先序遍历：DLR 中序遍历：LDR 后序遍历：LRD 对上图二叉树进行遍历 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> //二叉树结点 ...
C语言二叉树的递归遍历综合
wwxy1995的博客
12-17 306
二叉树的前序，中序，后序遍历本质上是深度优先搜索DFS,可以用过递归方法实现，求二叉树的高度，求二叉树叶子的个数，拷贝二叉树和删除二叉树，都可以通过递归的方式实现 代码 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef struct BINARYNODE { char ch; struct BINARYNODE* lch...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值