数据结构实验-栈和队列

原创 于 2025-01-23 18:14:30 发布 · 450 阅读 · 4 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#数据结构 #算法 #学习 #笔记 #c++

数据结构-栈和队列

四、栈的实现和应用

1、采用书上第 46 页定义的栈的顺序存储表示，编程实现栈的下列基本操作。
（1）初始化顺序栈 （2）创建顺序栈 （3）判断栈空 （4）输出顺序栈（5）取栈顶元素 （6）入栈 （7）出栈

#include <stdio.h>
#include <stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef int Status;
typedef int SElemType;
//存储空间初始分配量
//存储空间分配增量
typedef struct{
    SElemType *base;//在栈构造之前和销毁之后，base的值为NULL
    SElemType *top;//栈顶指针
    int stacksize;//当前已分配的存储空间，以元素为单位
}SqStack;

Status InitStack(SqStack &S){
//构造一个空栈S
    S.base =(SElemType*)malloc(STACK_INIT_SIZE* sizeof(SElemType));
    if(!S.base)exit(OVERFLOW);//存储分配失败
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE;
    return OK;
}//initStack

Status StackEmpty(SqStack &S){
    if(S.top==S.base)
        return TRUE;
    else
        return FALSE;
}//StackEmpty

Status GetTop(SqStack &S, SElemType &e){
    //若栈不空，则用e返回s的栈顶元素，并返回OK:否则返回ERROR
    if(S.top ==S.base) return ERROR;
    else e=*S.top;
    return OK;
}//GetTop

Status Push(SqStack &S, SElemType e){
    //插入元素e为新的栈顶元素
    if(S.top-S.base >=S.stacksize){//栈满，追加存储空间
        S.base = (SElemType* )realloc(S.base,(S.stacksize + STACKINCREMENT)* sizeof(SElemType));
        if (!S.base) exit(OVERFLOW);//存储分配失败
        S.top=S.base + S.stacksize;
        S.stacksize+=STACKINCREMENT;
    }
    S.top++;
    *S.top=e;
    S.stacksize++;
    return OK;
}//Push;

Status Pop(SqStack &S,SElemType &e){
    //若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK;否则返回ERROR
    if(S.top==S.base) return ERROR;
    else{
        e=*S.top;
        S.top--;
        S.stacksize--;
        return OK;
    }
}//Pop

Status Stackoutput(SqStack &S){
    //若栈不空，则从栈顶到栈底依次输出数据元素，并返回OK；否则返回ERROR
    SElemType *p;
    if(S.top==S.base)return ERROR;
    p=S.top;
    while(p!=S.base){
        printf("%d ",*p);
        p--;
    }
    printf("\n");
    return OK;
}//Stackoutput

Status StackTraverse(SqStack &S){
    //若栈不空，则从栈底到栈顶依次输出数据元素，并返回OK；否则返回ERROR
    SElemType *p;
    if(S.top==S.base)return ERROR;
    p=S.base+1;
    while(p!=S.top+1){
        printf("%d ",*p);
        p++;
    }
    printf("\n");
    return OK;
}//StackTraverse

int main(void){
    int i,n,k,h,a,b;
    SqStack S;
    printf("创建一个空栈！\n");
    InitStack(S);
    printf("判断栈是否为空！\n");
    printf("StackEmpty(S)=%d\n",StackEmpty(S));
    printf("创建栈的元素个数：\n");
    scanf("%d",&n);
    printf("输入%d个入栈元素的值:\n",n);
    for(i=0;i<n;i++){
        scanf("%d",&k);
        Push(S,k);
    }
    printf("逆序输出顺序栈元素值:\n");
    Stackoutput(S);
    printf("输出顺序栈元素值:\n");
    StackTraverse(S);
    printf("输入入栈元素值:");
    scanf("%d",&h);
    Push(S,h);
    printf("输出入栈后的顺序栈元素值:\n");
    StackTraverse(S);
    Pop(S,a);
    printf("输出第1个出栈元素值:%d\n",a);
    Pop(S,a);
    printf("输出第2个出栈元素值:%d\n",a);
    printf("输出两次出栈后顺序栈元素值:");
    StackTraverse(S);
    GetTop(S,b);
    printf("输出栈顶元素值：%d\n",b);
    return 0;
}

2、采用栈的顺序存储表示，编程实现表达式中圆括号“( )”和方括号“[ ]”匹配的检验。

#include <stdio.h>
#include <stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef int Status;
typedef char SElemType;
//存储空间初始分配量
//存储空间分配增量
typedef struct{
    SElemType *base;//在栈构造之前和销毁之后，base的值为NULL
    SElemType *top;//栈顶指针
    int stacksize;//当前已分配的存储空间，以元素为单位
}SqStack;

Status InitStack(SqStack &S){
//构造一个空栈S
    S.base =(SElemType*)malloc(STACK_INIT_SIZE* sizeof(SElemType));
    if(!S.base)exit(OVERFLOW);//存储分配失败
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE;
    return OK;
}//initStack

Status StackEmpty(SqStack &S){
    if(S.top==S.base)
        return TRUE;
    else
        return FALSE;
}//StackEmpty

Status GetTop(SqStack &S, SElemType &e){
    //若栈不空，则用e返回s的栈顶元素，并返回OK:否则返回ERROR
    if(S.top ==S.base) return ERROR;
    else e=*S.top;
    return OK;
}//GetTop

Status Push(SqStack &S, SElemType e){
    //插入元素e为新的栈顶元素
    if(S.top-S.base >=S.stacksize){//栈满，追加存储空间
        S.base = (SElemType* )realloc(S.base,(S.stacksize + STACKINCREMENT)* sizeof(SElemType));
        if (!S.base) exit(OVERFLOW);//存储分配失败
        S.top=S.base + S.stacksize;
        S.stacksize+=STACKINCREMENT;
    }
    S.top++;
    *S.top=e;
    S.stacksize++;
    return OK;
}//Push;

Status Pop(SqStack &S,SElemType &e){
    //若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK;否则返回ERROR
    if(S.top==S.base) return ERROR;
    else{
        e=*S.top;
        S.top--;
        S.stacksize--;
        return OK;
    }
}//Pop

Status Correct(SElemType str[]){
    //使用运算符栈S，当遇到'('、'['时进栈，遇到')'、']'出栈并判断出栈元素是否为相应的符号，若是则继续下一个，否则算法结束
    SqStack S;
    InitStack(S);//构造空栈
    int i,state=1;
    SElemType e;
    for(i=0;str[i]!='\0';i++){
        switch(str[i])
        {
            case '(':Push(S,str[i]);state++;break;
            case '[':Push(S,str[i]);state++;break;
            case ')':if(*S.top=='('){
                        Pop(S,e);
                        state--;
                    }
                    break;
            case ']':if(*S.top=='['){
                        Pop(S,e);
                        state--;
                    }
                    break;
        }
        if(!state)break;
    }
    if(StackEmpty(S)&&state==1)
        return OK;
    else
        return ERROR;
}//Correct

int main(void){
    SElemType str[100];
    printf("请输入带括号的表达式:\n");
    scanf("%s",str);
    if(Correct(str)==OK)
        printf("括号匹配正确！\n");
    else
        printf("括号匹配不正确！\n");
    return 0;
}

五、队列的存储表示和实现

1、采用书上第 61 页定义的队列的链式存储结构，编程实现队列的下列基本操作。
（1）构造空队列 （2）销毁队列 （3）清空队列 （4）判断队列是否为空 （5）求队列长度 （6）取队头元素 （7）插入队尾元素 （8）删除队头元素 （9）输出队列元素

//队列的链式表示
#include<stdio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define Status int
typedef int QElemType;
typedef struct QNode{
    QElemType data;
    struct QNode *next;
}QNode,*QueuePtr;
typedef struct{
    QueuePtr front;//队头指针
    QueuePtr rear;//队尾指针
}LinkQueue;

Status InitQueue(LinkQueue &Q){
    //构造一个空队列
    Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
    if(!Q.front) exit(OVERFLOW);
    Q.front->next=NULL;
    return OK;
}

Status DestroyQueue(LinkQueue &Q){
    //销毁队列Q
    while(Q.front){
        Q.rear=Q.front->next;
        free(Q.front);
        Q.front=Q.rear;
    }
    return OK;
}

Status ClearQueue(LinkQueue &Q){
    //将Q清为空队列
    QueuePtr p,q;
    if(!Q.front) exit(OVERFLOW);
    p=Q.front->next;
    Q.front->next=NULL;
    Q.rear=Q.front;
    while(p)
    {
        q=p;
        p=p->next;
        free(q);
    }
    return OK;
}

Status QueueEmpty(LinkQueue Q){
    //若队列Q为空队列，则返回TRUE,否则返回FALSE
    if(Q.front==Q.rear)
        return TRUE;
    else
        return FALSE;
}

int QueueLength(LinkQueue Q){
    //返回Q的元素个数，即队列的长度
    QueuePtr p;
    int n=0;
    p=Q.front;
    while(Q.rear!=p)
    {
        n++;
        p=p->next;
    }
    return n;
}

Status GetHead(LinkQueue Q,QElemType &e){
    //若队列不空，则用e返回Q的队头元素，并返回OK，否则返回ERROR
    QueuePtr p;
    if(Q.front==Q.rear) return ERROR;
    p=Q.front->next;
    e=p->data;
    return OK;
}

Status EnQueue(LinkQueue &Q,QElemType e){
    //插入元素e为Q的新的队尾元素
    QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
    if(!p) exit(OVERFLOW);//存储分配失败
    p->data=e;
    p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
    return OK;
}

Status DeQueue(LinkQueue &Q,QElemType &e){
    //若队列不空，则删除Q的队头元素，用e返回其值，并返回OK,否则返回ERROR
    if(Q.front==Q.rear) return ERROR;
    QueuePtr p=Q.front->next;
    e=p->data;
    Q.front->next=p->next;
    if(Q.rear==p) Q.rear=Q.front;
    free(p);
    return OK;
}

Status QueueTraverse(LinkQueue &Q){
    //从队头到队尾依次输出队列元素的值
    QueuePtr p=Q.front->next;
    if(p==NULL)return ERROR;
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
    return OK;
}

int main(void)
{
    int i,n;
    QElemType k,h,a,f;
    LinkQueue Q;
    printf("创建一个空队列！\n");
    InitQueue(Q);
    printf("判断队列是否为空！\n");
    printf("QueueEmpty(Q)=%d\n",QueueEmpty(Q));
    printf("创建队列的元素个数：\n");
    scanf("%d", &n);
    printf("输入%d个插入队列的元素的值:\n",n);
    for(i=0;i<n;i++)
    {
        scanf("%d", &k);
        EnQueue(Q, k);
    }
    printf("输出队列元素的个数：%d\n",QueueLength(Q));
    printf("输出队列元素的值：\n");
    QueueTraverse(Q);
    printf("输入插入队列的元素的值：");
    scanf("%d", &h);
    EnQueue(Q, h);
    printf("输出插入一个队列元素后队列元素的值：\n");
    QueueTraverse(Q);
    DeQueue(Q, a);
    printf("输出第1个删除的队头元素的值:%d\n", a);
    DeQueue(Q, a);
    printf("输出第2个删除的队头元素的值:%d\n", a);
    printf("输出两次删除队头元素后队列的元素值：");
    QueueTraverse(Q);
    GetHead(Q, f);
    printf("输出队头元素的值：%d\n",f);
    printf("输出队列元素的个数：%d\n",QueueLength(Q));
    printf("将Q清为空队列!\n");
    ClearQueue(Q);
    printf("输出队列元素的个数：%d\n",QueueLength(Q));
    printf("判断队列是否为空！\n");
    printf("QueueEmpty(Q)=%d\n",QueueEmpty(Q));
    return 0;
}

2、采用书上第 64 页定义的队列的顺序存储结构，编程实现循环队列的下列基本操作。
（1）构造空队列 （2）清空队列 （3）判断队列是否为空 （4）求队列长度 （5）取队头元素 （6）插入队尾元素 （7）删除队头元素 （8）输出队列元素

//队列的顺序表示：循环队列
#include<stdio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXQSIZE 100//最大队列长度
typedef int Status;
typedef int QElemType;
typedef struct {
    QElemType *base;//初始化的动态分配存储空间
    int front;//头指针，若队列不空，指向队列头元素
    int rear;//尾指针，若队列不空，指向队列尾元素的下一个位置
}SqQueue;

Status InitQueue(SqQueue &Q){
    //构造一个空队列
    Q.base=(QElemType *)malloc(MAXQSIZE*sizeof(QElemType));
    if(!Q.base) exit(OVERFLOW);
    Q.front=Q.rear=0;
    return OK;
}

Status CLearQueue(SqQueue &Q)
{
    //将Q清为空队列
    if(!Q.base) exit(OVERFLOW);
    Q.front=Q.rear=0;
    return OK;
}

Status QueueEmpty(SqQueue Q)
{
    //若队列Q为空队列，则返回TRUE，否则返回FALSE
    if(Q.rear==Q.front) return TRUE;
    else return FALSE;
}

int QueueLength(SqQueue Q){
    //返回Q的元素个数，即队列的长度
    return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
}

Status GetHead(SqQueue Q,QElemType &e){
    //若队列不空，则用e返回Q的队头元素，并返回OK，否则返回ERROR
    if(Q.front==Q.rear)return ERROR;
    e=Q.front;
    return OK;
}

Status EnQueue(SqQueue &Q,QElemType e){
    //插入元素e为新的队尾元素
    if((Q.rear+1)%MAXQSIZE==Q.front) return ERROR;//队列满
    Q.base[Q.rear]=e;
    Q.rear=(Q.rear+1)%MAXQSIZE;
    return OK;
}

Status DeQueue(SqQueue &Q,QElemType &e){
    ///若队列不空，则删除Q的队头元素，用e返回其值，并返回OK;否则返回ERROR
    if(Q.front == Q.rear)
        return ERROR;
    e = Q.base[Q.front];
    Q.front = (Q.front + 1) % MAXQSIZE;
    return OK;
}

Status QueueTraverse(SqQueue &Q){
    int i;
    if(Q.front==Q.rear) return ERROR;
    i = Q.front;
    while(i != Q.rear){
        printf("%d ",Q.base[i]);
        i = (i + 1) % MAXQSIZE;
    }
    printf("\n");
    return OK;
}

int main(void)
{
    int i,n;
    QElemType k,h,a,f;
    SqQueue Q;
    printf("创建一个空队列！\n");
    InitQueue(Q);
    printf("判断队列是否为空！\n");
    printf("QueueEmpty(Q)=%d\n",QueueEmpty(Q));
    printf("创建队列的元素个数：\n");
    scanf("%d", &n);
    printf("输入%d个插入队列的元素的值:\n",n);
    for(i=0;i<n;i++)
    {
        scanf("%d", &k);
        EnQueue(Q, k);
    }
    printf("输出队列元素的个数：%d\n",QueueLength(Q));
    printf("输出队列元素的值：\n");
    QueueTraverse(Q);
    printf("输入插入队列的元素的值：");
    scanf("%d", &h);
    EnQueue(Q, h);
    printf("输出插入一个队列元素后队列元素的值：\n");
    QueueTraverse(Q);
    DeQueue(Q, a);
    printf("输出第1个删除的队头元素的值:%d\n", a);
    DeQueue(Q, a);
    printf("输出第2个删除的队头元素的值:%d\n", a);
    printf("输出两次删除队头元素后队列的元素值：");
    QueueTraverse(Q);
    GetHead(Q, f);
    printf("输出队头元素的值：%d\n",f);
    printf("输出队列元素的个数：%d\n",QueueLength(Q));
    printf("将Q清为空队列!\n");
    CLearQueue(Q);
    printf("输出队列元素的个数：%d\n",QueueLength(Q));
    printf("判断队列是否为空！\n");
    printf("QueueEmpty(Q)=%d\n",QueueEmpty(Q));
    return 0;
}
数据结构实验栈和队列详细实验报告
04-15
实验三 栈和队列 3.1实验目的： （1） 熟悉栈的特点（先进后出）及栈的基本操作，如入栈、出栈等，掌握栈的基本操作在栈的顺序存储结构和链式存储结构上的实现； （2） 熟悉队列的特点（先进先出）及队列的基本操作，如入队、出队等，掌握队列的基本操作在队列的顺序存储结构和链式存储结构上的实现。 3.2 实验要求： （1） 复习课本中有关栈和队列的知识； （2） 用C语言完成算法和程序设计并上机调试通过； （3） 撰写实验报告，给出算法思路或流程图和具体实现（源程序）、算法分析结果（包括时间复杂度、空间复杂度以及算法优化设想）、输入数据及程序运行结果（必要时给出多种可能的输入数据和运行结果）。
数据结构试验2-栈和队列实验报告含源码
03-08
数据结构栈和队列实验报告，请放心下载
《数据结构》实验报告三：栈 队列
Amentos的博客
10-05 1万+
《数据结构》实验报告：栈和队列相关概念 + 入栈/出栈算法实现 + 十进制转二进制算法实现 + 只含一个尾指针的循环链队入队/出队算法代码
【数据结构】实验：栈和队列的操作及其应用
最新发布
m0_73970214的博客
08-09 1248
在编写病人看病程序时，代码要求病号不能重复，所以我在输入病历号数字的操作之中，加入了一个do…while循环，设立find变量，先遍历队列中以及存在的病号数字，若有重复，则find的值从0变为1，最终返回find的值来判断输入的病号是否重复，如果重复则需要重新输入病号。
数据结构实验（三）——栈和队列
FFFPAG的博客
08-18 4246
实验一： 内容： 编写一个程序，实现顺序栈（假设栈中元素类型ElemType为char）的各种基本运算，并在此基础上设计一个程序完成以下功能： 初始化栈s 判断栈s是否非空 依次进栈元素a，b，c，d，e 判断栈s是否非空 输出出栈序列 判断栈s是否非空 释放栈 程序： #include<iostream> #include<malloc.h> #define maxsize 100 using namespace std; typedef char ElemType;
数据结构实验--栈和队列操作
跳跳糖°的博客
04-17 4082
数据结构实验–顺序栈的操作 文章目录数据结构实验--顺序栈的操作一、实验要求二、实验核心算法二、实验代码示例 一、实验要求 编程实现栈的以下基本操作：建栈，取栈顶元素，入栈，出栈，显示顺序栈元素 二、实验核心算法 （1）定义顺序栈的存储结构，用base表示栈底指针，top表示栈顶指针，stacksize表示栈的容量 typedef struct { SElemType *base; //栈底指针 SElemType *top; //栈顶指针 int s
数据结构_实验三_栈和队列的操作_部分二
TengMMVP的博客
05-29 364
通过该实验，使学生理解循环队列的构造特点并灵活应用，掌握循环队列基本操作的编程实现，认识队列是在一端进行插入，在另一端进行删除集中操作的线性结构，掌握队列的“先入先出”操作特点，知道判断队列空和满的条件，进一步熟悉C语言中指针操作。没有初始化前进行其他操作，程序是否能控制住；销毁队，再做其他操作，判断程序是否能控制。结构，实现教材定义的循环队列的基本操作。4个数入队， 1、2、3、5；判队列空，屏幕显示队列为空；队列长度，屏幕输出4；出队，再判队列长度；
数据结构实验报告 栈和队列
喵头鹰的博客
04-26 1万+
一、实验目的1．掌握栈、队列的思想及其存储实现。 2．掌握栈、队列的常见算法的程序实现。二、实验仪器及环境：PC计算机 windows 7操作系统 CodeBlocks10.05三、实验内容及结果1．采用链式存储实现栈的初始化、入栈、出栈操作。 2．采用顺序存储实现栈的初始化、入栈、出栈操作。 3．采用链式存储实现队列的初始化、入队、出队操作。 4．采用顺序存
《数据结构》实验三：栈和队列实验 （实验报告）
热门推荐
denise94的专栏
11-05 5万+
一．实验目的      巩固栈和队列数据结构，学会运用栈和队列。 1.回顾栈和队列的逻辑结构和受限操作特点，栈和队列的物理存储结构和常见操作。 2.学习运用栈和队列的知识来解决实际问题。 3.进一步巩固程序调试方法。 4.进一步巩固模板程序设计。 二．实验时间    准备时间为第5周到第6周，具体集中实验时间为6周第2次课。2个学时。 三．实验内容
《数据结构》实验三：栈和队列实验报告
hslynn的专栏
11-09 3万+
一．.实验目的      巩固栈和队列数据结构，学会运用栈和队列。 1.回顾栈和队列的逻辑结构和受限操作特点，栈和队列的物理存储结构和常见操作。 2.学习运用栈和队列的知识来解决实际问题。 3.进一步巩固程序调试方法。 4.进一步巩固模板程序设计。 二．实验时间    准备时间为第5周到第6周，具体集中实验时间为6周第2次课。2个学时。 三．.实验内容 1.自己选择顺序或链式存储
数据结构实验三——栈和队列的基本操作
weiyuexin的博客
10-11 6273
** 一、实验内容 ** 1. 实验目的 编程实现顺序栈和链栈的基本操作：建栈，取栈顶元素，入栈，出栈； 编程实现循环队列和链队列的基本操作：建队列，取队头元素，入队，出队。 2. 基本要求 掌握栈的顺序存储结构、链式存储结构及其基本操作； 掌握队列的顺序存储结构、链式存储结构及其基本操作。 4. 支撑的课程目标 本实验项目可以支撑“目标1. 理解数据结构的基本概念、计算机内部数据对象的表示和特性。掌握线性表、树、图等数据逻辑结构、存储结构及其差异以及各种操作的实现。”、和“目标2能够针对实际问题选
数据结构实验报告—栈和队列
VLOKL的博客
03-31 4403
数据结构实验报告，栈，队列，C语言
数据结构---顺序表实验基本操作（超详细，含完整代码）
2302_79594931的博客
05-16 5253
线性表的基本操作 1.线性表的初始化 2.销毁线性表 3.清空线性表 4.判断线性表是否为空 5.求线性表的长度 6.获取指定位置的元素 7.求前驱 8.求后继 9.在线性表指定位置插入元素 10.删除指定位置元素 11.获取某元素的位置 12.显示线性表
数据结构栈与队列实验
dearzcs的博客
04-01 1602
后缀表达式
数据结构第二次试验：栈与队列
sjx3161的博客
04-18 1406
数据结构第二次试验：栈与队列前言一、实验内容第85页第2题第5小题第85页第2题第8小题二、实验环境三、实验目的四、算法设计五、实验代码六、实验结果截图七、实验分析（选做） 前言 为了帮助同学们完成痛苦的实验课程设计，本作者将其作出的实验结果及代码贴至CSDN中，供同学们学习参考。如有不足或描述不完善之处，敬请各位指出，欢迎各位的斧正！ 一、实验内容 第85页第2题第5小题 假设以I和O分别表示入栈和出栈操作。栈的始态和终态均为空，入栈和出栈的操作序列可表示为仅由I和O组成的序列，称可以操作的序列为合法序列
C++数据结构实验二栈和队列
qq_37856544的博客
01-21 3892
实验内容 1.建立一个空栈，并按要求完成：(顺序存储） （1）编写入栈函数，随机产生10个100以内的整数，并按输入顺序依次入栈,考虑判断上溢情况； （2）编写出栈函数，从键盘输入出栈元素个数n（n<10），将n个元素出栈并显示出栈元素，考虑判断下溢情况； （3）编写取栈顶元素函数，若栈不为空，则取出栈顶元素显示；否则提示栈空。 2. 建立一个空队列，并按要求完成：（链接存储） （1）编写入队函数，随机产生10个100以内的整数，并按输入顺序依次入队,考虑判断队满情况； （2）编写出队函数，从键盘输入
数据结构 实验四 栈和队列的基本操作的实现
m0_51308557的博客
12-19 4472
（1）用栈实现括号匹配的检验（2）用栈实现形如a+b@b+a#的中心对称的字符序列的检验。（3）用队列实现形如a+b@b+a#的中心对称的字符序列的检验
C++数据结构实验---栈和队列【多项式计算】
海到无边天作岸 山登绝顶我为峰
10-22 3153
实验二 栈和队列 1.实验内容与要求 理解栈和队列的逻辑结构及应用场景 针对实际问题选择循环队列或链栈的方法，编程实现构造、插入、删除等基本操作 掌握栈和队列的存储原理 2.实验环境 硬件环境：计算机 软件环境:vc++ 3.实验算法伪代码 计算优先级： char Priority(char ch1,char ch2){ int a; int b; switch(ch1){ case '=' : a=0; break; case '(' : a= 1; break;
数据结构实验报告二 栈和队列
G_M_R_的博客
12-31 7138
数据结构实验报告：实验二 栈和队列
数据结构---栈与队列实验报告
my0214163的博客
01-07 4048
一.上机实验的问题和要求： 数制转换 二.程序设计的基本思想，原理和算法描述： 算法描述：//十进制转换成其他进制 voidcoversion（） { intN,e，d;//十进制N转换成d进制数 InitStack（&S）；//构造空栈 scanf（“%d”，&N）； while（N） { e=N%d； Push（S,e）； N=N/d； } whlie（！StackEmpty（S）） { Pop（S，e）； printf（“%d...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Kethy__

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

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

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

打赏作者

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

抵扣说明：

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

余额充值