数据结构队列编程题

已于 2022-09-14 19:51:13 修改
阅读量1k 收藏 7
点赞数 2
分类专栏： # 队列 文章标签： 数据结构
于 2022-09-12 23:17:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65508678/article/details/126823167
版权

另类循环队列

如果用一个循环数组表示队列，并且只设队列头指针Front，不设尾指针Rear，而是另设Count记录队列中元素个数。请编写算法实现队列的入队和出队操作。

Code:

#include <bits/stdc++.h>
using namespace std;
const int M = 100;
int q[100], Front = 0, Count = 0;//front指向第一个元素

bool push(int x){
    if(Count >= M) return false;
    else {
        q[(Front + (Count ++ ) )%M] = x;
        return true;
    }
}

int pop(){
    if(Count <= 0) return INT32_MIN;
    else {
        return q[Front + ( -- Count)];
    }
}

void show(){
    cout << "当前队列内的元素为：";
    for(int i = 0; i < Count; ++i)
        cout << q[(Front + i)%M] << " ";
    cout << endl;
}

int main(){
    cout << "请选择操作: 1.入队, 2.出队, -1.退出" << endl;
    int op, p;
    cin >> op;
    while(op != -1){
        int x;
        switch (op){
            case 1:
                cin >> x;
                push(x);
                show();
                break;
            case 2:
                p = pop();
                if(p == INT32_MIN) cout << "队列为空" << endl;
                else cout << "出队的元素为:" <<  pop() << endl;
                break;
            default:
                 cout << "指令错误" << endl;
        }
        cout << "请选择操作: 1.入队, 2.出队, -1.退出" << endl;
        cin >> op;
    }
}

运行代码截图：

另：PTA原题

如果用一个循环数组表示队列，并且只设队列头指针Front，不设尾指针Rear，而是另设Count记录队列中元素个数。请编写算法实现队列的入队和出队操作。

函数接口定义：

bool AddQ( Queue Q, ElementType X );
ElementType DeleteQ( Queue Q );

其中Queue结构定义如下：

typedef int Position;
typedef struct QNode *PtrToQNode;
struct QNode {
    ElementType *Data;  /* 存储元素的数组   */
    Position Front;     /* 队列的头指针     */
    int Count;          /* 队列中元素个数   */
    int MaxSize;        /* 队列最大容量     */
};
typedef PtrToQNode Queue;

注意：如果队列已满，AddQ函数必须输出“Queue Full”并且返回false；如果队列是空的，则DeleteQ函数必须输出“Queue Empty”，并且返回ERROR。

裁判测试程序样例：

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

#define ERROR -1
typedef int ElementType;
typedef enum { addq, delq, end } Operation;
typedef enum { false, true } bool;
typedef int Position;
typedef struct QNode *PtrToQNode;
struct QNode {
    ElementType *Data;  /* 存储元素的数组   */
    Position Front;     /* 队列的头、尾指针 */
    int Count;          /* 队列中元素个数   */
    int MaxSize;        /* 队列最大容量     */
};
typedef PtrToQNode Queue; 

Queue CreateQueue( int MaxSize )
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
    Q->Front = 0;
    Q->Count = 0;
    Q->MaxSize = MaxSize;
    return Q;
}

bool AddQ( Queue Q, ElementType X );
ElementType DeleteQ( Queue Q );

Operation GetOp();  /* 裁判实现，细节不表 */

int main()
{
    ElementType X;
    Queue Q;
    int N, done = 0;

    scanf("%d", &N);
    Q = CreateQueue(N);
    while ( !done ) {
        switch( GetOp() ) {
        case addq: 
            scanf("%d", &X);
            AddQ(Q, X);
            break;
        case delq:
            X = DeleteQ(Q);
            if ( X!=ERROR ) printf("%d is out\n", X);
            break;
        case end:
            while (Q->Count) printf("%d ", DeleteQ(Q));
            done = 1;
            break;
        }
    }
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

4
Del
Add 5
Add 4
Add 3
Del
Del
Add 2
Add 1
Add 0
Add 10
End

输出样例：

Queue Empty
5 is out
4 is out
Queue Full
3 2 1 0

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

Code:

bool AddQ( Queue Q, ElementType X ){
	if(Q->MaxSize==Q->Count ){//队满
		printf("Queue Full\n");
		return false;
	}
	else{
		Q->Count ++;
		Q->Data [(Q->Front + Q->Count) % Q -> MaxSize] = X;// 改变队尾
		return true;
	}
}
ElementType DeleteQ( Queue Q ){
	if(Q->Count ==0){//队空
		printf("Queue Empty\n");
		return ERROR;
	}
	else{
		Q->Count -- ;
		Q->Front = (Q->Front + 1) % Q -> MaxSize;//改变队首
		return Q->Data [Q->Front  ];
	}
}

 双端队列

双端队列（deque，即double-ended queue的缩写）是一种具有队列和栈性质的数据结构，即可以（也只能）在线性表的两端进行插入和删除。若以顺序存储方式实现双端队列，请编写例程实现下列操作：

Push(X,D)：将元素X插入到双端队列D的头；
Pop(D)：删除双端队列D的头元素，并返回；
Inject(X,D)：将元素X插入到双端队列D的尾部；
Eject(D)：删除双端队列D的尾部元素，并返回。

思路：

 Push(X,D)：将元素X插入到双端队列D的头；（front -- ）
Pop(D)：删除双端队列D的头元素，并返回；（front ++）
Inject(X,D)：将元素X插入到双端队列D的尾部；（rear ++ ）
Eject(D)：删除双端队列D的尾部元素，并返回。(rear -- )

 Code:

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

class Deque{
    private:
        int front, rear, Count;
        int *p;
    public:
        static int MAX_SIZE;
        Deque();
        ~Deque(){ delete p;}
        bool push(int x);
        int pop();
        bool inject(int x);
        int eject();
        bool is_full();
        bool is_empty();
        void show();
};


int Deque::MAX_SIZE = 100;

Deque::Deque() : front(0), rear(1), Count(0){
    p = new int[Deque::MAX_SIZE];
}

bool Deque::push(int x){
    if(is_full()) return false;
    else {
        p[front] = x;
        front = (front-1+Deque::MAX_SIZE)%Deque::MAX_SIZE;
        Count++;
    }
}

int Deque::pop(){
    if(is_empty()) return INT32_MIN;
    else {
        front = (front+1)%Deque::MAX_SIZE;
        Count--;
        return p[front];
    }
}

bool Deque::inject(int x){
    if(is_full()) return false;
    else {
        p[rear] = x;
        rear = (rear+1)%Deque::MAX_SIZE;
        Count++;
    }
}

int Deque::eject(){
    if(is_empty()) return INT32_MIN;
    else {
        rear = (rear-1+Deque::MAX_SIZE)%Deque::MAX_SIZE;
        Count--;
        return p[rear];
    }
}

bool Deque::is_full(){
    return Count == Deque::MAX_SIZE;
}

bool Deque::is_empty(){
    return Count == 0;
}

void Deque::show(){
    cout << "当前队列中的元素: ";
    for(int i = 1; i <= Count; ++i)
        cout << p[(front+i)%Deque::MAX_SIZE] << " ";
    cout << endl;
}

int main(){
    Deque dq;
    int op;
    do{
        cout << "请输入操作:\n1.队头入队\t2.队头出队\t3.队尾入队\t4.队尾出队\t-1.结束\n";
        cin >> op;
        int x, tmp;
        switch(op){
            case 1:
                cin >> x;
                dq.push(x);
                dq.show();
                break;
            case 2:
                tmp = dq.pop();
                if(tmp == INT32_MIN) cout << "队列为空\n";
                else cout << "出队元素为" << tmp << endl;
                break;
            case 3:
                cin >> x;
                dq.inject(x);
                dq.show();
                break;
            case 4:
                tmp = dq.eject();
                if(tmp == INT32_MIN) cout << "队列为空\n";
                else cout << "出队元素为" << tmp << endl;
                break;
            default:
                if(op != -1) cout << "指令错误\n";
        }
    }while(op != -1);
}

注意：双端队列仍然是循环队列，否则存在假溢出。 

运行代码截图：

另：PTA原题

双端队列（deque，即double-ended queue的缩写）是一种具有队列和栈性质的数据结构，即可以（也只能）在线性表的两端进行插入和删除。若以顺序存储方式实现双端队列，请编写例程实现下列操作：

  • Push(X,D)：将元素X插入到双端队列D的头；
  • Pop(D)：删除双端队列D的头元素，并返回；
  • Inject(X,D)：将元素X插入到双端队列D的尾部；
  • Eject(D)：删除双端队列D的尾部元素，并返回。

函数接口定义：

bool Push( ElementType X, Deque D );
ElementType Pop( Deque D );
bool Inject( ElementType X, Deque D );
ElementType Eject( Deque D );

其中Deque结构定义如下：

typedef int Position;
typedef struct QNode *PtrToQNode;
struct QNode {
    ElementType *Data;      /* 存储元素的数组   */
    Position Front, Rear;   /* 队列的头、尾指针 */
    int MaxSize;            /* 队列最大容量     */
};
typedef PtrToQNode Deque;

注意：Push和Inject应该在正常执行完操作后返回true，或者在出现非正常情况时返回false。当Front和Rear相等时队列为空，Pop和Eject必须返回由裁判程序定义的ERROR。

裁判测试程序样例：

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

#define ERROR -1
typedef int ElementType;
typedef enum { push, pop, inject, eject, end } Operation;
typedef enum { false, true } bool;
typedef int Position;
typedef struct QNode *PtrToQNode;
struct QNode {
    ElementType *Data;      /* 存储元素的数组   */
    Position Front, Rear;   /* 队列的头、尾指针 */
    int MaxSize;            /* 队列最大容量     */
};
typedef PtrToQNode Deque; 

Deque CreateDeque( int MaxSize )
{   /* 注意：为区分空队列和满队列，需要多开辟一个空间 */
    Deque D = (Deque)malloc(sizeof(struct QNode));
    MaxSize++;
    D->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
    D->Front = D->Rear = 0;
    D->MaxSize = MaxSize;
    return D;
}

bool Push( ElementType X, Deque D );
ElementType Pop( Deque D );
bool Inject( ElementType X, Deque D );
ElementType Eject( Deque D );

Operation GetOp();          /* 裁判实现，细节不表 */
void PrintDeque( Deque D ); /* 裁判实现，细节不表 */

int main()
{
    ElementType X;
    Deque D;
    int N, done = 0;

    scanf("%d", &N);
    D = CreateDeque(N);
    while (!done) {
        switch(GetOp()) {
        case push: 
            scanf("%d", &X);
            if (!Push(X, D)) printf("Deque is Full!\n");
            break;
        case pop:
            X = Pop(D);
            if ( X==ERROR ) printf("Deque is Empty!\n");
            else printf("%d is out\n", X);
            break;
        case inject: 
            scanf("%d", &X);
            if (!Inject(X, D)) printf("Deque is Full!\n");
            break;
        case eject:
            X = Eject(D);
            if ( X==ERROR ) printf("Deque is Empty!\n");
            else printf("%d is out\n", X);
            break;
        case end:
            PrintDeque(D);
            done = 1;
            break;
        }
    }
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

3
Pop
Inject 1
Pop
Eject
Push 2
Push 3
Eject
Inject 4
Inject 5
Inject 6
Push 7
Pop
End

输出样例：

Deque is Empty!
1 is out
Deque is Empty!
2 is out
Deque is Full!
Deque is Full!
3 is out
Inside Deque: 4 5

代码长度限制

16 KB

时间限制

400 ms

内存限制

64 MB

Code:

bool Push(ElementType X, Deque D){
    if((D -> Rear + 1) % D -> MaxSize == D -> Front){//队满
        return false;
    }
    D -> Front = (D->Front -1 + D -> MaxSize) % D -> MaxSize;//front -- 
    D -> Data[D -> Front] = X;
    return true;
    
}
// ElementType Pop( Deque D ){
//     if(D -> Rear == D -> Front){//队空
//         return ERROR;
//     }
//     D -> Front = (D -> Front + 1) % D -> MaxSize;//front ++ 
//     return D->Data[D -> Front];
// }
ElementType Pop( Deque D ){
    int temp;//！！！！！！！！！！！！！！临时变量，储存pop前的data。
    if(D -> Rear == D -> Front){
        return ERROR;
    }
    temp = D->Front;
    D -> Front = (D -> Front + 1 ) % D -> MaxSize;
    return D -> Data[temp];
}
bool Inject( ElementType X, Deque D ){
    if((D -> Rear + 1) % D -> MaxSize == D -> Front){//队满
        return false;
    }
    D -> Data[D -> Rear] = X;//注意：数组从0开始到Maxsize - 1，故插入尾部只需Data[D -> Rear] 不需要Data[D -> Rear + 1]
    D -> Rear = (D -> Rear + 1) % D -> MaxSize;//rear ++ 
    return true;
}
ElementType Eject( Deque D ){
    if(D -> Rear == D -> Front){//队空
        return ERROR;
    }
    D -> Rear = (D -> Rear - 1 + D -> MaxSize) % D -> MaxSize;rear --
    return D -> Data[D -> Rear];
}

那就随便一点
关注
专栏目录
数据结构 - 队列 实现与常见题型（C语言）
qq_61386381的博客
05-21 1061
目录 前言： 队列的概念及结构 队列的实现 队列的定义 接口函数 实现接口函数 完整代码 Queue.h Queue.c 栈与队列的OJ练习 T1、用队列实现栈 T2、用栈实现队列 T3、设计循环队列 栈和队列的用途 前言： 队列的概念及结构 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 ............
JAVA语言程序设计与数据结构课后 编程题解析
12-22
在“JAVA语言程序设计与数据结构课后 编程题解析”这个主题中，我们可以深入探讨Java编程语言和数据结构的基础知识，以及如何通过解决课后编程题来提高编程技能。Java是一种广泛使用的面向对象的编程语言，它以其...
习题3.13 双端队列（25 分）浙大版《数据结构（第2版）》题目集
weixin_30905133的博客
10-09 467
双端队列（deque，即double-ended queue的缩写）是一种具有队列和栈性质的数据结构，即可以（也只能）在线性表的两端进行插入和删除。若以顺序存储方式实现双端队列，请编写例程实现下列操作： Push(X,D)：将元素X插入到双端队列D的头； Pop(D)：删除双端队列D的头元素，并返回； Inject(X,D)：将元素X插入到双端队列D的尾部； Eject(D)：...
数据结构：队列及其应用
最新发布
pranaa的博客
09-23 1141
队列（Queue）是一种特殊的线性表，它的主要特点是先进先出（First In First Out，FIFO）。队列只允许在一端（队尾）进行插入操作，而在另一端（队头）进行删除操作。
队列的经典例题—数据结构
m0_61963422的博客
11-04 675
队列的经典例题
数据结构之队列详解（包含例题）
hanwangyyds的博客
08-14 2142
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
数据结构练习(队列)
Java
02-24 1330
实验内容： 定义一个队列，要求用链表实现，使其具有如下功能： (1)初始化队列，要求得到一个空队列； (2) 入队操作，将一个元素放入队列中； (3) 出队操作，将元素从队列中删除； (4) 销毁队列。 以上每一步都做成函数，并给出相关代码。 参考代码： #include <stdio.h> #include <stdlib.h> /* 队列的头结点不存元素 */ //定义结构体 struct qnode{ int data ; struct qnode
数据结构编程题汇总
11-07
根据给定文件的信息，本文将围绕“数据结构编程题汇总”这一主题展开，重点解析与计算机专业课数据结构相关的考研编程题目。数据结构是计算机科学中的一个重要组成部分，它研究的是数据元素之间的逻辑关系以及对这些...
数据结构十八道编程题答案
12-24
交大的这十八道编程题显然是为了帮助学生深入理解各种数据结构及其应用。 一、数组与链表 数组是最基础的数据结构，它提供了随机访问的能力，但插入和删除元素的效率较低。链表则相反，其插入和删除操作通常更快，...
数据结构18道必做编程题
08-20
这18道必做编程题涵盖了数据结构的主要类型和操作，包括数组、链表、栈、队列、树、图等，旨在帮助你深入理解和应用这些概念。 1. **数组**：数组是最基本的数据结构，用于存储同类型的元素序列。编程题可能涉及...
编程题：构造队列
灰太狼
07-01 384
题目描述小明同学把1到n这n个数字按照一定的顺序放入了一个队列Q中。现在他对队列Q执行了如下程序：while(!Q.empty()) //队列不空，执行循环 { int x=Q.front(); //取出当前队头的值x Q.pop(); //弹出当前队头 Q.push(x); ...
＜栈和队列＞题目练习《数据结构(C语言版)》
m0_57859086的博客
06-03 2260
＜栈和队列＞题目练习《数据结构(C语言版)》 ——By 作者：新晓·故知
[编程题] 构造队列
赏星乐事
08-19 310
小明同学把1到n这n个数字按照一定的顺序放入了一个队列Q中。现在他对队列Q执行了如下程序： while(!Q.empty()) //队列不空，执行循环{int x=Q.front(); //取出当前队头的值xQ.pop(); //弹出当前队头Q.push(x); //把x放入队尾x = Q.
栈队列类编程题目
qq_43003252的博客
07-20 295
1 . 用两个栈实现队列 用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。 思路：用stack2用于输出，每次存入stack1，当要输入时，倒入到stack2。 代码： class Solution { public: void push(int node) { stack1.push(node); } int pop() { if(stack2.empty()) { whil
c语言编程队列题,数据结构C语言编程 队列.doc
weixin_26712075的博客
05-18 237
数据结构C语言编程 队列#include#include#define MAXQSIZE 10typedef struct{int *base; //存储空间的起始地址，即数组的首地址，即数组名int front; //顺序存储，即地址，所以用下标表示元素，front是第一个元的下标int rear; //rear是最后一个元素的下标}SqQue...
c语言编程队列题,[原创]C语言面试题 两个栈实现一个队列
weixin_35332816的博客
05-18 196
思路： 栈是先入后出，所以我们可以考虑把栈一的数据从栈顶把数据压到另一个缓冲栈栈里。然后缓冲栈依次出栈，就实现了先入先出的逻辑，然后再把数据压回去。#include #include#include/* run this program using the console pauser or add your own getch, system("pause") or input loop */i...
【数据结构】队列
拼命阿紫冲冲冲！
12-09 622
青春由磨砺而出彩，人生因奋斗而升华
【数据结构】LeetCode栈和队列经典题型
m0_56653788的博客
05-17 996
目录 1.有效的括号 2.用队列实现栈​编辑 3.用栈实现队列​编辑 4.设计循环队列 1.有效的括号 思路：因为左括号要和右括号顺序和类型都匹配，那么当从第一个右括号开始就要和左括号里最后一个匹配，如果匹配就下一个继续往后走。这样我们非常容易想到栈，左括号入栈，当遇到右括号就出栈，然后判断是否匹配，若不匹配就返回false，匹配就看下一个，直到栈为空。 代码：因为这里是C语言实现所有需要创建栈来使用，就用前面讲过的栈来用 typedef char STDataType; //栈必.
数据结构解析与编程题解答
"这是一份关于数据结构的学习资料，包含了多道编程题目和解析，旨在帮助学习者深入理解数据结构的理论与应用。" 在计算机科学中，数据结构是研究如何组织和管理数据的重要概念。它涉及到数据元素的集合以及它们之间...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

那就随便一点

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

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

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

打赏作者

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

抵扣说明：

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

余额充值