数据结构——二叉树、栈和队列、线性表综合实验

最新推荐文章于 2023-05-07 20:20:04 发布
最新推荐文章于 2023-05-07 20:20:04 发布
阅读量488 收藏 1
点赞数 1
分类专栏： C++ 文章标签： 数据结构 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TTTSEP9TH2244/article/details/122522167
版权

实验预备知识：

1. 熟练掌握二叉树的概念及性质。
2. 掌握栈和队列的概念及性质
3. 掌握线性表的概念及性质

一、实验目的

  1. 能利用二叉树的遍历解决实际问题。
  2. 加深对栈和队列的理解，能用栈和队列解决实际问题

二、实验要求

【项目1】 给定一个二叉树，设计一个算法，将其变成原二叉树的镜像。
程序代码：
Main.cpp:

#include <iostream>
#include "btree.h"

using namespace std;

int main()
{
    BTNode *b;
    char str[] = "A(B(,E),C(F))";
    CreateBTNode(b,str);
    DispBTNode(b);
    printf("\n");
    mirror(b);
    DispBTNode(b);
    DestroyBTNode(b);
    return 0;
}

Btree.h:

#ifndef BTREE_H_INCLUDED
#define BTREE_H_INCLUDED

#include <stdio.h>
#include <malloc.h>
#define MaxSize 100
typedef char ElemType;
typedef struct node
{
    ElemType data;              //数据元素
    struct node *lchild;        //指向左孩子
    struct node *rchild;        //指向右孩子
} BTNode;

typedef struct
{
    BTNode* node;
    int idx;
}BTNode1;

void CreateBTNode(BTNode *&b,char *str);        //由str串创建二叉链
BTNode *FindNode(BTNode *b,ElemType x);     //返回data域为x的节点指针
BTNode *LchildNode(BTNode *p);  //返回*p节点的左孩子节点指针
BTNode *RchildNode(BTNode *p);  //返回*p节点的右孩子节点指针
int BTNodeDepth(BTNode *b); //求二叉树b的深度
void DispBTNode(BTNode *b); //以括号表示法输出二叉树
void DestroyBTNode(BTNode *&b);  //销毁二叉树

void mirror(BTNode*&b);
#endif // BTREE_H_INCLUDED

Btree.cpp:

#include <stdio.h>
#include <malloc.h>
#include "btree.h"

void CreateBTNode(BTNode *&b,char *str)     //由str串创建二叉链
{
    BTNode *St[MaxSize],*p=NULL;
    int top=-1,k,j=0;
    char ch;
    b=NULL;             //建立的二叉树初始时为空
    ch=str[j];
    while (ch!='\0')    //str未扫描完时循环
    {
        switch(ch)
        {
        case '(':
            top++;
            St[top]=p;
            k=1;
            break;      //为左节点
        case ')':
            top--;
            break;
        case ',':
            k=2;
            break;                          //为右节点
        default:
            p=(BTNode *)malloc(sizeof(BTNode));
            p->data=ch;
            p->lchild=p->rchild=NULL;
            if (b==NULL)                    //p指向二叉树的根节点
                b=p;
            else                            //已建立二叉树根节点
            {
                switch(k)
                {
                case 1:
                    St[top]->lchild=p;
                    break;
                case 2:
                    St[top]->rchild=p;
                    break;
                }
            }
        }
        j++;
        ch=str[j];
    }
}
BTNode *FindNode(BTNode *b,ElemType x)  //返回data域为x的节点指针
{
    BTNode *p;
    if (b==NULL)
        return NULL;
    else if (b->data==x)
        return b;
    else
    {
        p=FindNode(b->lchild,x);
        if (p!=NULL)
            return p;
        else
            return FindNode(b->rchild,x);
    }
}
BTNode *LchildNode(BTNode *p)   //返回*p节点的左孩子节点指针
{
    return p->lchild;
}
BTNode *RchildNode(BTNode *p)   //返回*p节点的右孩子节点指针
{
    return p->rchild;
}
int BTNodeDepth(BTNode *b)  //求二叉树b的深度
{
    int lchilddep,rchilddep;
    if (b==NULL)
        return(0);                          //空树的高度为0
    else
    {
        lchilddep=BTNodeDepth(b->lchild);   //求左子树的高度为lchilddep
        rchilddep=BTNodeDepth(b->rchild);   //求右子树的高度为rchilddep
        return (lchilddep>rchilddep)? (lchilddep+1):(rchilddep+1);
    }
}
void DispBTNode(BTNode *b)  //以括号表示法输出二叉树
{
    if (b!=NULL)
    {
        printf("%c",b->data);
        if (b->lchild!=NULL || b->rchild!=NULL)
        {
            printf("(");
            DispBTNode(b->lchild);
            if (b->rchild!=NULL) printf(",");
            DispBTNode(b->rchild);
            printf(")");
        }
    }
}
void DestroyBTNode(BTNode *&b)   //销毁二叉树
{
    if (b!=NULL)
    {
        DestroyBTNode(b->lchild);
        DestroyBTNode(b->rchild);
        free(b);
    }
}
void mirror(BTNode*&b)
{
    if(b == NULL)
        return;
    BTNode *temp;
    temp = b->lchild;
    b->lchild = b->rchild;
    b->rchild = temp;
    mirror(b->lchild);
    mirror(b->rchild);
}

运行结果截图：
在这里插入图片描述
【项目2】用两个栈来实现一个队列，完成队列的出队和入队操作。 队列中的元素为int类型。
程序代码：
Main.cpp:

#include <iostream>
#include <stdio.h>
//#include "btree.h"
#include "sqstack.h"

using namespace std;

int main()
{
    int temp;
    int e;
    while(scanf("%d",&temp)&&temp!=0)
    {
        if(temp>0)
        {
            enQueue(temp);
            printf("%d入队\n",temp);
        }
        else if(temp<0)
        {
            if(deQueue(e))
                printf("%d出队\n",e);
            else
                printf("出队失败\n");
        }
    }
    return 0;
}

Sqstack.h:

#ifndef SQSTACK_H_INCLUDED
#define SQSTACK_H_INCLUDED

#define MaxSize 100
typedef int ElemType;
typedef struct
{
    ElemType data[MaxSize];
    int top;                //栈指针
} SqStack;                  //顺序栈类型定义

void InitStack(SqStack *&s);    //初始化栈
void DestroyStack(SqStack *&s);  //销毁栈
bool StackEmpty(SqStack *s);     //栈是否为空
int StackLength(SqStack *s);  //返回栈中元素个数——栈长度
bool Push(SqStack *&s,ElemType e); //入栈
bool Pop(SqStack *&s,ElemType &e); //出栈
bool GetTop(SqStack *s,ElemType &e); //取栈顶数据元素
void DispStack(SqStack *s);  //输出栈

bool enQueue(int elem);
bool deQueue(int& e);
#endif // SQSTACK_H_INCLUDED

Sqstack.cpp:

#include <stdio.h>
#include <malloc.h>
#include "sqstack.h"

void InitStack(SqStack *&s)
{
    s=(SqStack *)malloc(sizeof(SqStack));
    s->top=-1;
}
void DestroyStack(SqStack *&s)
{
    free(s);
}
int StackLength(SqStack *s)  //返回栈中元素个数——栈长度
{
    return(s->top+1);
}
bool StackEmpty(SqStack *s)
{
    return(s->top==-1);
}
bool Push(SqStack *&s,ElemType e)
{
    if (s->top==MaxSize-1)    //栈满的情况，即栈上溢出
        return false;
    s->top++;
    s->data[s->top]=e;
    return true;
}
bool Pop(SqStack *&s,ElemType &e)
{
    if (s->top==-1)     //栈为空的情况，即栈下溢出
        return false;
    e=s->data[s->top];
    s->top--;
    return true;
}
bool GetTop(SqStack *s,ElemType &e)
{
    if (s->top==-1)         //栈为空的情况，即栈下溢出
        return false;
    e=s->data[s->top];
    return true;
}

void DispStack(SqStack *s)  //输出栈
{
    int i;
    for (i=s->top;i>=0;i--)
        printf("%c ",s->data[i]);
    printf("\n");
}

ElemType stk1[MaxSize];
int top1 = -1;
ElemType stk2[MaxSize];
int top2 = -1;
bool enQueue(int elem)
{
    stk1[++top1] = elem;
}
bool deQueue(int& e)
{
    ElemType temp;
    if(top2 == -1)
    {
        while(top1 != -1)
        {
            temp = stk1[top1--];
            stk2[++top2] = temp;
        }
    }
    if(top2 == -1)
        return false;
    e = stk2[top2--];
    return true;
}

运行结果截图：
在这里插入图片描述
【项目3】输入一个链表，输出该链表中倒数第k个结点。
程序代码：
Main.cpp:

#include <iostream>
#include <stdio.h>
#include "linklist.h"

using namespace std;

int main()
{
    LinkList *L;
    LinkList *p;
    int n = 10;
    ElemType a[] = {1,2,3,4,5,6,7,8,9,10};
    CreateListR(L,a,n);
    p = findNode(L,8);
    printf("%d\n",p->data);
    DestroyList(L);
    return 0;
}

Linklist.h:

#ifndef LINKLIST_H_INCLUDED
#define LINKLIST_H_INCLUDED

typedef int ElemType;
typedef struct LNode        //定义单链表结点类型
{
    ElemType data;
    struct LNode *next;     //指向后继结点
}LinkList;
void CreateListF(LinkList *&L,ElemType a[],int n);//头插法建立单链表
void CreateListR(LinkList *&L,ElemType a[],int n);//尾插法建立单链表
void InitList(LinkList *&L);  //初始化线性表
void DestroyList(LinkList *&L);  //销毁线性表
bool ListEmpty(LinkList *L);  //判断线性表是否为空
int ListLength(LinkList *L);  //求线性表长度
void DispList(LinkList *L);  //输出线性表
bool GetElem(LinkList *L,int i,ElemType &e);  //求线性表某个数据元素值
int LocateElem(LinkList *L,ElemType e);  //按元素值查找
bool ListInsert(LinkList *&L,int i,ElemType e);  //插入数据元素
bool ListDelete(LinkList *&L,int i,ElemType &e);  //删除数据元素
LinkList *findNode(LinkList *L,int k);
#endif // LINKLIST_H_INCLUDED

List.cpp：

#include <stdio.h>
#include <malloc.h>
#include "linklist.h"


void CreateListF(LinkList *&L,ElemType a[],int n)//头插法建立单链表
{
    LinkList *s;
    int i;
    L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点
    L->next=NULL;
    for (i=0; i<n; i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));//创建新结点
        s->data=a[i];
        s->next=L->next;            //将*s插在原开始结点之前,头结点之后
        L->next=s;
    }
}

void CreateListR(LinkList *&L,ElemType a[],int n)//尾插法建立单链表
{
    LinkList *s,*r;
    int i;
    L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点
    L->next=NULL;
    r=L;                    //r始终指向终端结点,开始时指向头结点
    for (i=0; i<n; i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));//创建新结点
        s->data=a[i];
        r->next=s;          //将*s插入*r之后
        r=s;
    }
    r->next=NULL;           //终端结点next域置为NULL
}

void InitList(LinkList *&L)
{
    L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点
    L->next=NULL;
}
void DestroyList(LinkList *&L)
{
    LinkList *p=L,*q=p->next;
    while (q!=NULL)
    {
        free(p);
        p=q;
        q=p->next;
    }
    free(p);    //此时q为NULL,p指向尾结点,释放它
}
bool ListEmpty(LinkList *L)
{
    return(L->next==NULL);
}
int ListLength(LinkList *L)
{
    LinkList *p=L;
    int i=0;
    while (p->next!=NULL)
    {
        i++;
        p=p->next;
    }
    return(i);
}
void DispList(LinkList *L)
{
    LinkList *p=L->next;
    while (p!=NULL)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}
bool GetElem(LinkList *L,int i,ElemType &e)
{
    int j=0;
    LinkList *p=L;
    while (j<i && p!=NULL)
    {
        j++;
        p=p->next;
    }
    if (p==NULL)            //不存在第i个数据结点
        return false;
    else                    //存在第i个数据结点
    {
        e=p->data;
        return true;
    }
}
int LocateElem(LinkList *L,ElemType e)
{
    LinkList *p=L->next;
    int n=1;
    while (p!=NULL && p->data!=e)
    {
        p=p->next;
        n++;
    }
    if (p==NULL)
        return(0);
    else
        return(n);
}
bool ListInsert(LinkList *&L,int i,ElemType e)
{
    int j=0;
    LinkList *p=L,*s;
    while (j<i-1 && p!=NULL) //查找第i-1个结点
    {
        j++;
        p=p->next;
    }
    if (p==NULL)    //未找到位序为i-1的结点
        return false;
    else            //找到位序为i-1的结点*p
    {
        s=(LinkList *)malloc(sizeof(LinkList));//创建新结点*s
        s->data=e;
        s->next=p->next;                        //将*s插入到*p之后
        p->next=s;
        return true;
    }
}
bool ListDelete(LinkList *&L,int i,ElemType &e)
{
    int j=0;
    LinkList *p=L,*q;
    while (j<i-1 && p!=NULL)    //查找第i-1个结点
    {
        j++;
        p=p->next;
    }
    if (p==NULL)                //未找到位序为i-1的结点
        return false;
    else                        //找到位序为i-1的结点*p
    {
        q=p->next;              //q指向要删除的结点
        if (q==NULL)
            return false;           //若不存在第i个结点,返回false
        e=q->data;
        p->next=q->next;        //从单链表中删除*q结点
        free(q);                //释放*q结点
        return true;
    }
}
LinkList *findNode(LinkList *L,int k)
{
    if(L == NULL)
        return NULL;
    LinkList *p1 = L,*p2 = L;
    while (k>0 && p2 != NULL){
        p2 = p2->next;
        k--;
    }
    //p2 指向head说明k<=0,p2==null && k>0说明 k超过了链表的长度
    if(p2 == L || (p2 == NULL && k>0))
        return  NULL;
    while (p2!=NULL)
    {
        p1 = p1->next;
        p2 = p2->next;
    }
    return p1;
}

运行结果截图：
在这里插入图片描述

爱吃苹果的派大星
关注
专栏目录
数据结构——栈与队列
m0_57484470的博客
10-17 6445
数据结构栈与队列相关基础知识详解！！！
线性表 —— 栈和队列
qq_52473141的博客
10-30 706
栈和队列栈和队列栈和队列的定义与特点案例引入栈S基本操作顺序栈链式栈队列Q循环队列链队栈与递归 栈和队列 栈和队列的定义与特点 栈和队列是限定插入和删除只能在表的“端点”进行的线性表 栈：先进后出，后进先出，eg：数值转换、表达式求值、括号匹配检验、八皇后问题、行编辑程序、函数调用、迷宫求解、递归调用的实现 队列：先进先出，处理程序设计中类似排对问题的有用工具 案例引入 进制转换 转换法则：除以d倒取余 括号匹配 检验：①可以利用一个栈结构保存每个出现的左括号，当遇到右括号时，从栈中弹出左括号，检查
二叉树实验三 二叉树的综合操作
12-08
//按照先序非递归遍历二叉树 void preorder(BiTree T) { BiTree*stack[100];//定义栈 int top ; if(T!=NULL) {top=1; stack[top]=T;//进栈 while(top>0) { T=stack[top] ; top--; printf("%c",T->data);//出栈 if(T->rchild!=NULL) {top++; stack[top]=T->rchild;//右孩子进栈 } if(T->lchild!=NULL) {top++; stack[top]=T->lchild;//左孩子进栈 } } } } //按照先序递归遍历二叉树 void DLR(BiTree T) { if(T!=NULL) { printf("%c",T->data); DLR(T->lchild); DLR(T->rchild); } } //按照中序遍历二叉树 void LDR(BiTree T) { if(T!=NULL) { LDR(T->lchild); printf("%c",T->data); LDR(T->rchild); } } //按照后序递归遍历二叉树 void LRD(BiTree T) { if(T!=NULL) { LRD(T->lchild); LRD(T->rchild); printf("%c",T->data); } }
数据结构实训报告(线性表+栈和队列+二叉树+图+排序)
我们都有光明的未来
12-02 3508
数据结构实训报告，实验报告(线性表+栈和队列+二叉树+图+排序)
实验5:树和二叉树的实验1
Ulong_的博客
05-09 1441
一、实验目的1、 熟练理解树和二叉树的相关概念，掌握的存储结构和相关操作实现；2、 掌握树的顺序结构的实现；3、 学会运用树的知识解决实际问题二、 实验内容自己确定一个二叉树（树结点类型、数目和结构自定）利用顺序结构方法存储。实现树的构造，并完成：1）层序输出结点数据；2）以合理的格式，输出各个结点和双亲、孩子结点信息；3）输出所有的叶子结点信息；4）分析你的算法对于给定的二叉树的存储效率。三、实...
数据结构实验报告;1-线性表的应用,栈和队列,串,树和二叉树
01-04
T串在S串中出现的位置与次数,建立一个非递减表，插入一个元素,建立一个非递减表，删相同元素,交换元素,链队列与循环队列的入队和出队,树,用算符优先法求表达式值.
数据结构课设——实验三 基于线性表和二叉排序树的低频词过滤系统
m0_52625385的博客
06-23 1341
基于线性表和二叉排序树的低频词过滤系统 前言  本题和我之前自学python时做过的一道“Hamlet英文词频统计”很相似，故本文代码实现采用python，且基于原来的代码做修改。  但是由于笔者学艺不精，不清楚python中的一些语法（如python里不像C++用指针的方式构建二叉树）故在二叉排序树的一些方面参考了一部分他人的python构建二叉排序树代码，原文网址如下： 文章目录基于线性表和二叉排序树的低频词过滤系统前言一、实验内容实现提示：二、算法流程及代码实现2.1 文本读取和处理2.2 线性表的实
数据结构实验报告（包括线性表、栈和队列、串、二叉树、图、查找与排序算法的设计与实现）
最新发布
06-09
### 数据结构实验报告知识点概述 #### 一、线性表基本运算 ...以上是对数据结构实验报告中提到的主要知识点的概述，这些知识点覆盖了数据结构的核心内容，对于理解和掌握数据结构的基础概念和实际应用具有重要的意义。
数据结构与算法实验，线性表，栈和队列，二叉树，图结构
01-18
在这个实验中，我们将深入探讨四个核心概念：线性表、栈和队列、二叉树以及图结构。这些概念构成了许多高级算法的基础，广泛应用于软件开发、数据库设计、网络通信等多个领域。 1. 线性表：线性表是最基本的数据...
数据结构实验与习题线性表栈和队列串数组树与二叉树
03-04
本书《数据结构实验与习题——线性表栈和队列串数组树与二叉树》旨在帮助学生更好地理解和实践这些概念。 首先，书中介绍了C语言基础知识，这是实现数据结构的基础。C语言的基本输入输出、函数及其参数传递、以及...
寒假训练营 第2节：线性表，栈，队列，二叉树
m0_73870738的博客
12-25 187
寒假训练营 第2节：线性表，栈，队列，二叉树学习整理
数据结构基础（线性表+栈+队列+树+图）
weixin_43321444的博客
03-29 1626
根据数据元素之间分为4类基本结构： （1）集合（2）线性结构（3）树形结构（4）图状结构或网状结构 typedef int Status; 双向链表中插入一个结点时指针的变化情况： s -> prior = p -> prior; p -> proir -> next = s; s -> next = p; p -> proir = s; ...
【数据结构】代码实现(线性表、栈、队列、串、树、图)
slience_me的博客
10-24 562
数据结构 一、线性表 1. 顺序表(静态分配) #include <iostream> using namespace std; #define TRUE 1 //逻辑真 #define FALSE 0 //逻辑假 #define OK 1 //正确 #define ERROR 0 //错误 #define INFEASIBLE -1 //不可能，非法操作 #define
数据结构与算法（一）:线性表、栈、树(二叉树，AVL树)、图
Machine Learning with Tutors
01-08 1578
数据结构是以某种形式将数据组织在一起的集合，它不仅存储数据，还支持访问和处理数据的操作。算法是为求解一个问题需要遵循的、被清楚指定的简单指令的集合。下面是自己整理的常用数据结构与算法相关内容，如有错误，欢迎指出。
数据结构（顺序表，栈，队列，串，查找，排序）
qq_43467170的博客
10-05 606
数据结构（顺序表，栈，队列，串，查找，排序）
数据结构课程设计(C语言实现)
亲爱的老吉先森呀
05-07 2602
设计一个应用程序（C/C++），利用多级菜单实现单链表、栈、队列、二叉树及图五种结构的基本操作及应用。
数据结构之二叉树实验
// 在校菜鸟大学生的日常学习博客
09-01 4664
二叉树实验实验目的实验环境实验要求实验内容源代码运行结果 实验目的 通过实验掌握二叉树的基本存储结构； 掌握二叉树的建立与遍历的基本算法，并加以应用； 实验环境 CodeBlocks 实验要求 熟悉c语言的语法知识； 掌握二叉树的链式存储结构—二叉链表的定义、构造、遍历等基本操作； 实验内容 完成二叉树的二叉链表的存储结构的定义、创建、前序遍历、中序遍历、后序遍历、求叶子数和求深度等函数的编写。完成以下函数的编写： (1) 编写一个函数输出结点的值。visit( BiTree T) (2)编写一个函
数据结构实验四 :二叉树的综合应用
qq_45158661的博客
04-22 3080
二叉树的综合应用：对于给定的字符串“ABF#C#G##DE##H###”，用递归的方法实现以下算法： （1）以二叉链表表示二叉树，建立一棵二叉树； （2）输出二叉树的中序遍历结果； （3）输出结点“C”的左右孩子的值； （4）计算二叉树的深度； （5）统计二叉树的叶子结点个数； （6）统计二叉树的度为1的结点个数；
编写一个程序btree.cpp， 实现二叉树基本运算
热门推荐
xx7755223的博客
10-17 1万+
（验证性实验）实现二叉树的各种基本运算的算法 编写一个程序btree.cpp， 实现二叉树基本运算，并在此基础上设计一个程序exp5-1.cpp，完成如下功能。由图所示的二叉树创建对应的二叉链存储结构b，叉树的括号表示串为“A(B(D,E(H(J,K(L,M(,N))))),C(,I)))”输出二叉树b输出‘H’结点的左、右孩子结点值输出二叉树b的高度释放二叉树b 代码如下 btree //二叉树的基本运算算法 #include <stdio.h>#include <malloc.h
《数据结构》实验指导书——线性表与栈队列操作
"这是一本数据结构的实验指导书，主要涵盖了数据结构中的核心概念和算法，包括线性表、栈、队列、串、二叉树、图、哈希表以及排序算法的实践操作。这本书是针对南京工程学院通信工程学院的信息工程和计算机通信专业...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值