[NEFU锐格 数据结构]实验二 栈和队列有关的操作

最新推荐文章于 2022-11-23 15:36:19 发布
最新推荐文章于 2022-11-23 15:36:19 发布
阅读量2.1k 收藏 17
点赞数 14
分类专栏： # 数据结构 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39354847/article/details/120183640
版权
本文详细介绍了NEFU大学二年级课程中关于链式队列（Queue）和栈（Stack）的基本操作，包括队列的入队、出队、判断空队列等，以及如何利用栈实现杨辉三角和进制转换。通过实例演示了链式队列和栈在算法中的实用技巧。
摘要由CSDN通过智能技术生成

[NEFU锐格 数据结构]实验二 栈和队列有关的操作

推荐阅读
[数据结构]NEFU 大二上 锐格实验参考 目录

知识点

题目知识点
8797链式队列计算杨辉三角
8563顺序存储栈基本操作
8562链式栈基本操作
8566利用栈实现进制转化
8569利用栈进行表达式计算
8564链式队列基本操作
8565循环队列基本操作

题目

8797

5-6班的版本（没啥格式要求）

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdbool.h>

typedef struct Node{
    int data;
    struct Node *next;
}LQNode,*LinkQNode;
typedef struct{
    LQNode *front,*rear;
}LQueue,*LinkQueue;

int QueueInit(LinkQueue &Q){
    LinkQNode p;
    Q=(LinkQueue)malloc(sizeof(LQueue));//申请头尾指针节点
    p=(LinkQNode)malloc(sizeof(LQNode));//申请链队头节点
    p->next=NULL;Q->front=Q->rear=p;
    return 1;
}
void QueuePush(LinkQueue &Q,int x){
    LinkQNode p=(LinkQNode)malloc(sizeof(LQNode));
    p->data=x;
    p->next=NULL;
    Q->rear->next=p;
    Q->rear=p;
}
bool QueueEmpty(LinkQueue Q){
    if(Q->front==Q->rear)return true;
    return false;
}
bool QueuePop(LinkQueue &Q,int &x){
    if(QueueEmpty(Q)){
        puts("Queue Empty!");
        return 0;
    }
    LinkQNode p=Q->front->next;
    Q->front->next=p->next;
    x=p->data;
    if(p==Q->rear)Q->rear=Q->front;//只有一个元素的话，出队后为空
    delete p;
    return 1;
}
bool GetHead(LinkQueue Q,int &head){
    if(QueueEmpty(Q))return false;
    head=Q->front->next->data;
    return true;
}
int main(){
    int n,out,head;scanf("%d",&n);
    LinkQueue Q;
    QueueInit(Q);QueuePush(Q,1);
    for(int i=2;i<=n;i++){
        QueuePush(Q,1);
        for(int j=1;j<=i-2;j++){
            QueuePop(Q,out);
            printf("%d ",out);
            GetHead(Q,head);
            out+=head;
            QueuePush(Q,out);
        }
        QueuePop(Q,out);
        printf("%d ",out);
        QueuePush(Q,1);
        puts("");
    }
    while(!QueueEmpty(Q)){
        QueuePop(Q,out);
        printf("%d ",out);
    }
    return 0;
}

7-8班的版本（有格式要求）
我觉得吧，这种题目拿格式来搞你就没意思了，而且锐格他不显示空格就好烦，我拿尺子看有没有对齐的。考试的时候吧，我建议手写个队列走个流程，然后直接printf答案。

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdbool.h>

typedef struct Node{
    int data;
    struct Node *next;
}LQNode,*LinkQNode;
typedef struct{
    LQNode *front,*rear;
}LQueue,*LinkQueue;

int QueueInit(LinkQueue &Q){
    LinkQNode p;
    Q=(LinkQueue)malloc(sizeof(LQueue));//申请头尾指针节点
    p=(LinkQNode)malloc(sizeof(LQNode));//申请链队头节点
    p->next=NULL;Q->front=Q->rear=p;
    return 1;
}
void QueuePush(LinkQueue &Q,int x){
    LinkQNode p=(LinkQNode)malloc(sizeof(LQNode));
    p->data=x;
    p->next=NULL;
    Q->rear->next=p;
    Q->rear=p;
}
bool QueueEmpty(LinkQueue Q){
    if(Q->front==Q->rear)return true;
    return false;
}
bool QueuePop(LinkQueue &Q,int &x){
    if(QueueEmpty(Q)){
        puts("Queue Empty!");
        return 0;
    }
    LinkQNode p=Q->front->next;
    Q->front->next=p->next;
    x=p->data;
    if(p==Q->rear)Q->rear=Q->front;//只有一个元素的话，出队后为空
    delete p;
    return 1;
}
bool GetHead(LinkQueue Q,int &head){
    if(QueueEmpty(Q))return false;
    head=Q->front->next->data;
    return true;
}
int main(){
    int n,out,head;scanf("%d",&n);
    LinkQueue Q;
    QueueInit(Q);QueuePush(Q,1);
    for(int i=2;i<=n;i++){
        for(int j=2*(n-i)+1;j>=0;j--)printf(" ");
        QueuePush(Q,1);
        for(int j=1;j<=i-2;j++){
            QueuePop(Q,out);
            if(out<10)printf(" ");
            printf("%d  ",out);
            
            GetHead(Q,head);
            out+=head;
            QueuePush(Q,out);
        }
        QueuePop(Q,out);
        printf(" %d",out);
        QueuePush(Q,1);
        puts("");
    }
    if(!QueueEmpty(Q)){
        QueuePop(Q,out);
        printf(" 1  ");
    
        while(!QueueEmpty(Q)){
        QueuePop(Q,out);
        if(out<10)printf(" ");
        printf("%d  ",out);
    }
    }
    //printf("\n2");
    return 0;
}

8563

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdbool.h>
#define MAXSIZE 1024
typedef struct {
    int data[MAXSIZE];
    int top;
}SeqStack;

bool StackInit(SeqStack &S){
    S.top=-1;return 1;
}
bool StackEmpty(SeqStack S){
    if(S.top==-1)return 1;
    return 0;
}
bool StackPush(SeqStack &S,int x){
    if(S.top==MAXSIZE-1){
        puts("栈满");
        return 0;
    }
    S.top++;
    S.data[S.top]=x;
    return 1;
}
bool StackPop(SeqStack &S,int &x){
    if(S.top==-1){
        puts("栈空");
        return 0;
    }
    x=S.data[S.top];
    S.top--;
    return 0;
}
bool StackGetTop(SeqStack S,int &x){
    if(S.top==-1){
        puts("栈空");
        return 0;
    }
    x=S.data[S.top];
    return 1;
}
int main(){
    int x;
    SeqStack Stk;
    StackInit(Stk);
    while(~scanf("%d",&x)){
        if(x==0)break;
        StackPush(Stk,x);
    }
    while(!StackEmpty(Stk)){
        StackPop(Stk,x);
        printf("%d ",x);
    }
    return 0;
}

8562

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdbool.h>

typedef struct StackNode{
    int data;
    struct StackNode *next;
}StackNode,*LinkStack;

bool StackInit(LinkStack &top){
    top=NULL;return 1;
}
bool StackEmpty(LinkStack top){
    if(top==NULL)return 1;
    return 0;
}
void StackPush(LinkStack &top,int x){
    StackNode *s;
    s=(StackNode*)malloc(sizeof(StackNode));
    s->data=x;
    s->next=top;
    top=s;
}
bool StackPop(LinkStack &top,int &x){
    if(top==NULL){
        puts("Stack Empty!");return 0;
    }
    x=top->data;
    StackNode *p=top;
    top=top->next;
    free(p);
    return 1;
}

int main(){
    int x;
    LinkStack Stk;
    StackInit(Stk);
    while(~scanf("%d",&x)){
        if(x==0)break;
        StackPush(Stk,x);
    }
    while(!StackEmpty(Stk)){
        StackPop(Stk,x);
        printf("%d ",x);
    }
    return 0;
}

8566

如果不是直接pop输出的话注意数据可能爆long long

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdbool.h>
#define MAXSIZE 1024
typedef struct {
    int data[MAXSIZE];
    int top;
}SeqStack;

bool StackInit(SeqStack &S){
    S.top=-1;return 1;
}
bool StackEmpty(SeqStack S){
    if(S.top==-1)return 1;
    return 0;
}
bool StackPush(SeqStack &S,int x){
    if(S.top==MAXSIZE-1){
        puts("栈满");
        return 0;
    }
    S.top++;
    S.data[S.top]=x;
    return 1;
}
bool StackPop(SeqStack &S,int &x){
    if(S.top==-1){
        puts("栈空");return 0;
    }
    x=S.data[S.top];
    S.top--;
    return 0;
}
bool StackGetTop(SeqStack S,int &x){
    if(S.top==-1){
        puts("栈空");return 0;
    }
    x=S.data[S.top];
    return 1;
}

long long convert(int x,int r){
    SeqStack Stk;
    StackInit(Stk);
    while(x){
        StackPush(Stk,x%r);
        x/=r;
    }
    long long res=0;
    int e;
    while(!StackEmpty(Stk)){
        StackPop(Stk,e);
        res=res*10+e;
    }
    return res;
}
int main(){
    int a,r;scanf("%d%d",&a,&r);
    long long b=convert(a,r);
    printf("%d(10)=%lld(%d)",a,b,r);
    return 0;
}

8569

上课上到了再补不用STL的写法

在这里插入代码片

可扩展运算符的c++代码

#include<bits/stdc++.h>
using namespace std;

const int N=1e5+10;
stack<int> num;
stack<char> op;

void eval(){
    auto b=num.top();num.pop();
    auto a=num.top();num.pop();
    auto c=op.top();op.pop();
    int x;
    if(c=='+')x=a+b;
    else if(c=='-')x=a-b;
    else if(c=='*')x=a*b;
    else x=a/b;
    num.push(x);
}
int main()
{
    unordered_map<char,int>pr{{'+',1},{'-',1},{'*',2},{'/',2}};//运算符优先级
    string s;
    cin>>s;
    for(int i=0;i<s.size();i++)
    {
        auto c=s[i];
        if(isdigit(c))//转数字
        {
            int x=0,j=i;
            while(j<s.size()&&isdigit(s[j]))
                x=x*10+s[j++]-'0';
            i=j-1;
            num.push(x);
        }
        else if(c=='(')op.push(c);
        else if(c==')')//括号直接算
        {
            while(op.top()!='(')eval();
            op.pop();
        }
        else
        {
            while(op.size()&&pr[op.top()]>=pr[c])eval();//如果当前优先级比前面的低就算
            op.push(c);//操作符入栈
        }
    }
    while(op.size())eval();//剩余计算
    printf("%d",num.top());
    return 0;
}

8564

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdbool.h>

typedef struct Node{
    int data;
    struct Node *next;
}LQNode,*LinkQNode;
typedef struct{
    LQNode *front,*rear;
}LQueue,*LinkQueue;

int QueueInit(LinkQueue &Q){
    LinkQNode p;
    Q=(LinkQueue)malloc(sizeof(LQueue));//申请头尾指针节点
    p=(LinkQNode)malloc(sizeof(LQNode));//申请链队头节点
    p->next=NULL;Q->front=Q->rear=p;
    return 1;
}
void QueuePush(LinkQueue &Q,int x){
    LinkQNode p=(LinkQNode)malloc(sizeof(LQNode));
    p->data=x;
    p->next=NULL;
    Q->rear->next=p;
    Q->rear=p;
}
bool QueueEmpty(LinkQueue Q){
    if(Q->front==Q->rear)return true;
    return false;
}
int QueuePop(LinkQueue &Q,int &x){
    if(QueueEmpty(Q)){
        puts("Queue Empty!");
        return 0;
    }
    LinkQNode p=Q->front->next;
    Q->front->next=p->next;
    x=p->data;
    if(p==Q->rear)Q->rear=Q->front;//只有一个元素的话，出队后为空
    delete p;
    return 1;
}
bool GetHead(LinkQueue Q,int &head){
    if(QueueEmpty(Q))return false;
    head=Q->front->next->data;
    return true;
}
int main(){
    LinkQueue Q;
    QueueInit(Q);
    int x;
    while(~scanf("%d",&x)){
        if(x==0)break;
        QueuePush(Q,x);
    }
    while(!QueueEmpty(Q)){
        QueuePop(Q,x);
        printf("%d ",x);
    }
    return 0;
}

8565

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdbool.h>

#define MAXSIZE 1024
typedef struct{
    int data[MAXSIZE];
    int front,rear;
}SeQueue;

bool QueueInit(SeQueue &Q){
    Q.front=0;Q.rear=0;
    return 1;
}
bool QueuePush(SeQueue &Q,int x){
    if((Q.rear+1)%MAXSIZE==Q.front){
        puts("队列满");return 0;
    }
    Q.data[Q.rear]=x;
    Q.rear=(Q.rear+1)%MAXSIZE;
    return 1;
}
bool GetHead(SeQueue Q,int &x){
    if(Q.front==Q.rear){
        puts("队列空");return 0;
    }
    x=Q.data[Q.front];
    return 1;
}
bool QueueEmpty(SeQueue Q){
    if(Q.front==Q.rear)return 1;
    return 0;
}
bool QueuePop(SeQueue &Q,int &x){
    if(Q.front==Q.rear){
        puts("队列空");return 0;
    }
    x=Q.data[Q.front];
    Q.front=(Q.front+1)%MAXSIZE;
}

int main(){
    SeQueue Q;
    QueueInit(Q);
    int x;
    while(~scanf("%d",&x)){
        if(x==0)break;
        QueuePush(Q,x);
    }
    while(!QueueEmpty(Q)){
        QueuePop(Q,x);
        printf("%d ",x);
    }
    return 0;
}
鱼竿钓鱼干
关注
专栏目录
数据结构实验二 栈、队列
而濡木染
04-24 1157
实验内容： 1．采用链式存储实现栈的初始化、入栈、出栈操作。 2．采用顺序存储实现栈的初始化、入栈、出栈操作。 3．采用链式存储实现队列的初始化、入队、出队操作。 4．采用顺序存储实现循环队列的初始化、入队、出队操作。 5．在主函数中设计一个简单的菜单，分别测试上述算法。 1.链式栈（相当于一个先入后出 的单链表） #include #include ///链式栈 ty
数据结构实验二——栈和队列
NightOwl's Cliff
05-08 3617
1.1．编写一个程序，实现顺序栈的各种基本运算，并在此基础上设计一个主程序完成如下功能： （1）初始化栈s； （2）判断栈s是否为空； （3）依次进栈元素-1,2,10,-3,5； （4）判断栈s是否为空； （5）输出栈长度； （6）输出从栈顶到栈底的元素； （7）输出出栈序列； （8）判断栈s是否为空。 我的代码如下： #include "c1.h" #define Ma
栈与队列的应用（数据结构实验二）
qq_62984481的博客
04-29 189
//后缀法 #include <stdio.h> #include <stdlib.h> #define _LINKSTACK_H #include <stdio.h> #include <stdlib.h> #define SUCCESS 10000 #define FAILURE 10001 #define TRUE 10002 #define FALSE 10003 typedef int Elemtype; typedef int ...
数据结构实验2栈与队列
weixin_44780625的博客
07-07 685
文章目录一、 实验目的或任务二、 实验教学基本要求三、 实验教学的内容或要求需要word文件请关注该公众号，回复对应内容即可。 一、 实验目的或任务 通过指导学生上机实践，对常用数据结构的基本概念及其不同的实现方法的理论得到进一步的掌握，并对在不同存储结构上实现不同的运算方式和技巧有所体会。 二、 实验教学基本要求 1.了解实验目的及实验原理； 2.编写程序，并附上程序代码和结果图； 3.总结在编程过程中遇到的问题、解决办法和收获。 三、 实验教学的内容或要求 1.编写函数,采用链式存储实现栈的初始化、入栈
实验2 栈和队列的基本操作、算法和应用
AZXYZNPY的博客
11-23 592
就是假设自己脑袋上是 x-y，那么由于他知道另外两个人的数是啥（即 x 和 y），他也知道 x > y，那么就是说 (x, y, x-y) 中最大的是 x，那么如果在轮到头上是 x 的那个人在他理应猜出来的那步时还回答不出来，就说明自己头上的数不可能是 x-y，那么就可以从 (x, y, x-y) 这个局面的答案退出 (x, y, x+y) 这个局面的答案了。如果不是出口且为走过该路径，则将当前位置的标记数改为1，并将当前位置压入栈中，在将位置定位到下一个节点，并把mov值设为0。满则返回ERROR。
数据结构锐格实验二：栈和队列的有关操作
nefu_Luxembourg的博客
05-10 734
8563 題目內容: 试编写算法，采用顺序存储实现栈的初始化、入栈、出栈操作。要求输入整形数据，输入0表示结束（0不存储在栈中）。 输入输出说明: 输入：1 2 3 4 5 6 7 8 9 0 输出：9 8 7 6 5 4 3 2 1 #include <bits/stdc++.h> #define Maxsize 1000 using namespace std; typedef struct { int data[Maxsize]; int top; }Sqstack;
【NEFU锐格】数据结构实验二
qq_65022282的博客
10-28 548
NEFU数据结构
NEFU锐格网络平台（实验课）用于莫拉莱斯存储锐格做过的题。.zip
最新发布
03-29
【NEFU锐格网络平台】是一个专为教育领域设计的在线网络平台，尤其适用于莫拉莱斯存储和管理学生在锐格上完成的题目。这个平台可能是为了方便教学、实践和学习过程中的作业提交与批改而开发的。从标题来看，这个平台...
2022-nefu-数据结构课设完整版本
09-27
线性结构如数组、链表、栈和队列，它们的数据元素呈线性排列，具有前后关系。数组是最基本的数据结构，提供了随机访问但插入和删除操作较慢；链表则允许动态调整大小，插入和删除效率较高。栈是一种后进先出（LIFO）...
[NEFU锐格】 数据结构 实验一
qq_65022282的博客
09-28 351
nefu锐格数据结构实验一
数据结构实验报告《二、栈和队列的运用》
11-29
数据结构实验报告 《二、栈和队列的运用》
数据结构实验报告2-栈与队列-队列基本操作算法-实验内容及要求.docx
07-06
编写程序，建立容量为n(建议n=8)的循环队列，完成以下程序功能。输入字符#，执行一次出队操作，屏幕上显示出队字符；输入字符@，队列中所有字符依次出队并按出队次序在屏幕上显示各字符；输入其它字符，则输入的字符入队。 要求采用队头/队尾间隔至少一个空闲元素的方法来实现循环队列；空队执行出队操作及队满执行入队操作需显示提示信息。
数据结构试验2-栈和队列实验报告含源码
03-08
数据结构栈和队列实验报告，请放心下载
数据结构实验2 栈和队列
SakuraZhangrx的博客
12-13 274
#include<iostream> #include<algorithm> #include<stdlib.h> #include<stdio.h> const int maxsize = 2; using namespace std; int size123=0; typedef struct car { int carnum; int intime; }car; typedef struct carout { int carnum; in
数据结构实验报告二 栈和队列
G_M_R_的博客
12-31 6815
数据结构实验报告：实验二 栈和队列
数据结构实训二——栈与队列
我们都有光明的未来
12-23 631
1.实验目的： （1）掌握顺序栈的和链队列的实现； （2）能利用栈和队列的基本运算解决实际问题； 2.实验要求： 车场是一个可停放n辆汽车的狭长通道，且只有一个大门可供进出（栈结构）。 汽车在停车场内按车辆到达的先后顺序依次排列。 若停车场内的已停满汽车，则后来的车只能在门外的变道上等候，一旦停车场内有车开走， 则排在便道上的第一辆车即可进入（队列结构）。 每辆停放在停车场的车，在离开时按其在停车场停留时间长短交费（在这里假设车不能从门外等侯便道上直接开走）。 试设计一个实现停车场管理的程序，按照从终端输入
数据结构实验2-栈和队列
Pengwill's Blog
03-03 4319
实现顺序栈的基本运算 实验要求 程序代码 运行结果 实现链栈基本运算 实验要求 程序代码 运行结果 实现循环队列的基本运算 实验要求 程序代码 运行结果 实现链队列的基本运算 实验要求 程序代码 运行结果 实现顺序栈的基本运算 实验要求 编写一个程序，实现顺序栈的各种基本运算，并在此基础上设计一个主程序完成如下功能： （1）初始化栈s； （2）判断栈s...
数据结构第二次试验：栈与队列
sjx3161的博客
04-18 1254
数据结构第二次试验：栈与队列前言一、实验内容第85页第2题第5小题第85页第2题第8小题二、实验环境三、实验目的四、算法设计五、实验代码六、实验结果截图七、实验分析（选做） 前言 为了帮助同学们完成痛苦的实验课程设计，本作者将其作出的实验结果及代码贴至CSDN中，供同学们学习参考。如有不足或描述不完善之处，敬请各位指出，欢迎各位的斧正！ 一、实验内容 第85页第2题第5小题 假设以I和O分别表示入栈和出栈操作。栈的始态和终态均为空，入栈和出栈的操作序列可表示为仅由I和O组成的序列，称可以操作的序列为合法序列
数据实验结构（二）——栈和队列的设计与实现
不忘初心，方得始终。
06-15 928
栈和队列的设计与实现
二进制运算详解：与、或、非、异或及移位操作
"林大ACM内部交流-二...理解这些基本的二进制运算对于学习计算机科学和参与ACM竞赛至关重要，因为它们是许多高效算法和数据结构的基础。通过熟练掌握这些概念，程序员可以编写出更快、更简洁的代码来解决复杂的问题。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值