PTA:双端队列

之前有进行队列的学习,当时老师有提过双端队列的概念,不过没有深入,今天突然想到了,于是想要探索一下双端队列的实现方式以及与普通队列的对比。

题目引入:

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

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

函数接口定义:

cpp 复制代码
bool Push( ElementType X, Deque D );
ElementType Pop( Deque D );
bool Inject( ElementType X, Deque D );
ElementType Eject( Deque D );

其中Deque结构定义如下:

cpp 复制代码
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。

裁判测试程序样例:

cpp 复制代码
#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

先回忆一下队列的一些基本结构:

通常情况下,顺序队列会采用环形缓冲区实现,以避免 "假溢出"的情况,

Front:指向队列头元素的前一个位置(空位置)。

Rear:指向队列尾元素的当前位置。

空队列条件:Front == Rear(头尾指针重合)。

满队列条件:(Rear + 1) % MaxSize == Front(尾指针的下一个位置是头指针)。

解题思路:

因为是循环队列,所以我们设数组下标递增方向表示 "顺时针",下标递减方向表示 "逆时针"。

1、Push 函数:若队列未满则将 Front 指针逆时针移动一位,并在新的 Front 位置插入元素。

2、Pop 函数:非空则获取 Front 位置的元素并将 Front 指针顺时针移动一位

3、Inject 函数:队列未满则在 Rear 位置插入元素并将 Rear 指针顺时针移动一位

4、Eject 函数:非空则将 Rear 指针逆时针移动一位并返回新的 Rear 位置的元素。

**边界条件:使用取模运算(核心)来处理循环队列的边界,判断队列是否满和空。

代码如下:

其实理清了思路,代码就很好实现了。

cpp 复制代码
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;
    D->Data[D->Front] = X;
    return true;
}

ElementType Pop(Deque D) {
    if (D->Front == D->Rear) {
        return ERROR;
    }
    ElementType x = D->Data[D->Front];
    D->Front = (D->Front + 1) % D->MaxSize;
    return x;
}

bool Inject(ElementType X, Deque D) {
    if ((D->Rear + 1) % D->MaxSize == D->Front) {
        return false;
    }
    D->Data[D->Rear] = X;
    D->Rear = (D->Rear + 1) % D->MaxSize;
    return true;
}

ElementType Eject(Deque D) {
    if (D->Front == D->Rear) {
        return ERROR;
    }
    D->Rear = (D->Rear - 1 + D->MaxSize) % D->MaxSize;
    return D->Data[D->Rear];
}

与普通队列对比

1、普通队列(Queue)

特性:遵循 FIFO(先进先出) 原则,就相当于排队。

操作限制:

入队(Enqueue):只能在队列尾部(Rear)插入元素。

出队(Dequeue):只能在队列头部(Front)删除元素。

2、双端队列(Deque)

特性:同时具备队列和栈的特性,操作灵活。

操作限制:

没有操作限制,两端都可以对数据元素进行操作。

3、差异表
特性 普通队列(Queue) 双端队列(Deque)
操作限制 尾部插入,头部删除(FIFO) 两端均可插入和删除
应用场景 任务调度、BFS 等严格 FIFO 场景 滑动窗口、回文检查、栈 / 队列实现
实现复杂度 较低 较高(需支持双向操作)

今天的分享就到这里啦~~

相关推荐
电科_银尘4 小时前
【大模型算法与工程 15】手写Self-Attention:Q、K、V与缩放点积
算法
我不会插花弄玉6 小时前
13.多路转接epoll【由浅入深-网络】
网络·c++·epoll
郝学胜-神的一滴8 小时前
Effective STL 条款03:容器中的对象复制要廉价且正确
开发语言·数据结构·c++·算法·rpc·stl
秋天的怀念_David8 小时前
算法一千零一夜 · 第三十三夜 · 跳表
java·程序人生·算法
西西弗Sisyphus9 小时前
C++ explicit 关键字工程实践
开发语言·c++
Pniubi11 小时前
力扣21合并两个有序链表
算法·leetcode·职场和发展
AIgorithmGEEK11 小时前
std::unordered_map 与 std::unordered_set:接口、算法技巧与权衡 (速查)
c++·算法·哈希表·负载因子·桶·unordered_map·unordered_set
上海潭龙东海科技有限公司12 小时前
智慧堆场动态模型三维实时孪生重构智能管控
大数据·网络·数据库·算法·重构
一拳一个呆瓜13 小时前
【STL】头文件:<cmath>
c++·stl
草莓熊Lotso14 小时前
【C++ 基于微服务的即时通讯系统】ElasticSearch 用户数据管理实现
linux·数据库·c++·elasticsearch·微服务·架构