队列重点OJ题

最新推荐文章于 2023-04-01 23:42:34 发布
最新推荐文章于 2023-04-01 23:42:34 发布
阅读量113 收藏
点赞数
文章标签： 数据结构 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_72766756/article/details/128546415
版权

一.队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出

FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头.

二:OJ题😜
    • 用队列实现栈

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

思路：保持一个队列存数据一个队列为空，出数据时，倒一下

typedef int QDataType;

typedef struct QueueNode
{
    QDataType data;
    struct QueueNode* next;

}QNode;

typedef struct Queue
{
    QNode* head;
    QNode* tail;
    int size;
}Queue;

void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);
int QueueSize(Queue* pq);

void QueueInit(Queue* pq)
{
    assert(pq);

    pq->head = NULL;
    pq->tail = NULL;
    pq->size = 0;

}
void QueueDestroy(Queue* pq)
{
    assert(pq);

    QNode* cur = pq->head;
    while (cur)
    {
        QNode* del = cur;
        cur = cur->next;

        free(del);
    }
    pq->head = pq->tail = NULL;
    pq->size = 0;
}
void QueuePush(Queue* pq, QDataType x)
{
    assert(pq);

    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (newnode == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    newnode->data = x;
    newnode->next = NULL;

    if (pq->tail==NULL)
    {
        pq->head = pq->tail = newnode;
    }
    else
    {
        pq->tail->next = newnode;
        pq->tail = newnode;
    }
    pq->size++;
}
void QueuePop(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));

    if (pq->head->next == NULL)
    {
        free(pq->head);
        pq->head = pq->tail = NULL;
    }
    else
    {
        QNode* del = pq->head;
        pq->head = pq->head->next;

        free(del);
    }
    pq->size--;
}
QDataType QueueFront(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));

    return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));

    return pq->tail->data;
}
bool QueueEmpty(Queue* pq)
{
    assert(pq);

    return pq->head == NULL&& pq->tail == NULL;
}
int QueueSize(Queue* pq)
{
    assert(pq);

    /*int size = 0;
    QNode* cur = pq->head;
    while (cur)
    {
        cur = cur->next;
        ++size;
    }
    return size;*/
    return pq->size;

}

typedef struct {
Queue q1;
Queue q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack*obj=(MyStack*)malloc(sizeof(MyStack));
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);

    return obj;
}

void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
}

int myStackPop(MyStack* obj) {
    Queue*emptyQ=&obj->q1;
    Queue*nonemptyQ=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        emptyQ=&obj->q2;
        nonemptyQ=&obj->q1;
    }
    //非空队列的前n-1个数据导入空队列
    while(QueueSize(nonemptyQ)>1)
    {
        QueuePush(emptyQ,QueueFront(nonemptyQ));
        QueuePop(nonemptyQ);
    }

    int top=QueueFront(nonemptyQ);
    QueuePop(nonemptyQ);

    return top;
}

int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}
2:用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

  • void push(int x) 将元素 x 推到队列的末尾

  • int pop() 从队列的开头移除并返回元素

  • int peek() 返回队列开头的元素

  • boolean empty() 如果队列为空，返回 true ；否则，返回 false

typedef int STDatatype;
typedef struct Stack
{
    STDatatype* a;
    int capacity;
    int top;  
}ST;

void StackInit(ST* ps);
void StackDestroy(ST* ps);
void StackPush(ST* ps, STDatatype x);
void StackPop(ST* ps);
STDatatype StackTop(ST* ps);

bool StackEmpty(ST* ps);
int StackSize(ST* ps);
void StackInit(ST* ps)
{
    assert(ps);

    //ps->a = NULL;
    //ps->top = 0;
    //ps->capacity = 0;
    //也可这样写

    ps->a = (STDatatype*)malloc(sizeof(STDatatype) * 4);
    if (ps->a == NULL)
    {
        perror("mallloc fail");
        exit(-1);
    }
    ps->top = 0;
    ps->capacity = 4;

}

void StackDestroy(ST* ps)
{
    assert(ps);

    free(ps->a);
    ps->a = NULL;
    ps->top = ps->capacity = 0;

}
void StackPush(ST* ps, STDatatype x)
{
    assert(ps);

    if (ps->top==ps->capacity)
    {
        STDatatype* tmp = (STDatatype*)realloc(ps->a, ps->capacity * 2 * sizeof(STDatatype));
        if (tmp == NULL) 
        {
            perror("realloc fail");
            exit(-1);
        }
        ps->a = tmp;
        ps->capacity *= 2;
    }
    ps->a[ps->top] = x;
    ps->top++;
}
void StackPop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps)); 
    ps->top--;

}
STDatatype StackTop(ST* ps)
{
    assert(ps);
    assert(!StackEmpty(ps));

    return ps->a[ps->top - 1];
}

bool StackEmpty(ST* ps)
{
    assert(ps);
    
    return ps->top == 0;

}
int StackSize(ST* ps)
{
    assert(ps);

    return ps->top;
}


typedef struct {
    ST pushst;
    ST popst;
} MyQueue;

bool myQueueEmpty(MyQueue* obj);
MyQueue* myQueueCreate() {
    MyQueue*pq=(MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&pq->popst);
    StackInit(&pq->popst);

    return pq;
}

void myQueuePush(MyQueue* obj, int x) {
    assert(obj);

    StackPush(&obj->pushst,x);
}
bool myQueueEmpty(MyQueue* obj) {
    assert(obj);
    return StackEmpty(&obj->pushst)&&StackEmpty(&obj->popst);

}

int myQueuePeek(MyQueue* obj);
int myQueuePop(MyQueue* obj) {
    assert(obj);
    assert(!myQueueEmpty(obj));

    int peek=myQueuePeek(obj);
    StackPop(&obj->popst);

    return peek;
}

int myQueuePeek(MyQueue* obj) {
    assert(obj);
    assert(!myQueueEmpty(obj));
//倒数距
    if(StackEmpty(&obj->popst))
    {
        while(StackEmpty(&obj->pushst))
        {
            StackPush(&obj->popst,StackTop(&obj->pushst));
            StackPop(&obj->pushst);
        }
    }

    return StackTop(&obj->popst);

}



void myQueueFree(MyQueue* obj) {

    assert(obj);

    StackDestroy(&obj->pushst);
    StackDestroy(&obj->popst);

    free(obj);
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/
3. 设计循环队列

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。你的实现应该支持如下操作

思路（单链表）：1.增加一个空余节点--->rear的next等于front就是满，front等于rear就是空；2：加个size，size等于k就是满，两个相等就是空；

（数组）：增加一个空间，两个相等就是空，满是（rear+1）%（k+1）== front；

typedef struct {
    int*a;
    int front;
    int rear;
    int k;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue*obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    //多开一个
    obj->a=(int*)malloc(sizeof(int)*(k+1));
    obj->front=obj->rear=0;
    //满的时候存储数据的个数，空间大小应该是k+1；
    obj->k=k;

    return obj;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    assert(obj);
    return obj->rear==obj->front;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    assert(obj);
    return ((obj->rear+1)%(obj->k+1))==obj->front;

}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    assert(obj);

    if(myCircularQueueIsFull(obj))
    return false;
    
    obj->a[obj->rear++]=value;
    obj->rear%=(obj->k+1);
    return true;

}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    assert(obj);

    if(myCircularQueueIsEmpty(obj))
    return false;

    obj->front++;
    obj->front%=(obj->k+1);
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
        return -1;
    else
        return obj->a[obj->front];

}

int myCircularQueueRear(MyCircularQueue* obj) {
 assert(obj);
    if(myCircularQueueIsEmpty(obj))
        return -1;
    //k是数据个数
    else
    return obj->a[(obj->rear+obj->k)%(obj->k+1)];
}


void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);

}

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/

过过过.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
OJ习题.zip
12-22
OJ习题.zip
【C语言】浅_刷 —— 栈 - 队列 OJ题，看了就会~（详解版）
上上谦. 的博客
04-04 1666
有了上面队列的结构，再加上之前实现的栈的结构，我们来做几道OJ练习来加强对知的理解。
【单调队列优化DP】LNSYOJ#106. 猴子
bangzuan5029的博客
12-15 258
这是一道思路比较简单但是调试极其毒瘤的一道题目！ 题目描述 一个猴子找到了很多香蕉树，这些香蕉树都种在同一直线上，而猴子则在这排香蕉树的第一棵树上。这个猴子当然想吃尽量多的香蕉，但它又不想在地上走，而只想从一棵树跳到另一棵树上。同时猴子的体力也有限，它不能一次跳得太远或跳的次数太多。每当他跳到一棵树上，它就会把那棵树上的香蕉都吃了。那么它最多能吃多少个香蕉呢？ 输入格式 输...
栈和队列OJ题合集(包含循环队列的两种实现)
2301_76269963的博客
04-01 1413
栈和队列OJ题合集(包含循环队列的两种实现)
2020年2月12日 OJ习题【队列】
shiroi2333的博客
02-12 236
报数-队列-约瑟夫环 思路：把n个人放在队列里，通过循环一次报数，同时记录队首，当到m的倍数是就直接出队了，否则要先出队再入队 #include <bits/stdc++.h> using namespace std; queue<int>x; int n,m,k; int main() { cin>>n>>m; for(int i=...
南阳oj 题目21 三个水杯
南风古
05-10 975
三个水杯时间限制：1000 ms | 内存限制：65535 KB 难度：4描述 给出三个水杯，大小不一，并且只有最大的水杯的水是装满的，其余两个为空杯子。三个水杯之间相互倒水，并且水杯没有标识，只能根据给出的水杯体积来计算。现在要求你写出一个程序，使其输出使初始状态到达目标状态的最少次数。 输入 第一行一个整数N(0<N<50)表示N组测试数据 接下来每组测试数据有两行，第一行给出三
OJ系统蓝桥杯题库
12-03
OJ系统的蓝桥杯题库，http://oj.xpuca.top/，这里有这些题的栗子。
C语言回文数OJ题和答案
10-22
打印所有小于65536且是完全平方数的回文数。
华为OJ试题
10-23
java实现的，华为OJ试题汇总，包括一些等差序列求和，数组查找等函数实现
从各大的OJ平台提取的题库
04-16
这是从各大的OJ平台提取的题库，虽然不全但是经典，分享给大家，使用能打开HTML的软件都能打开的。文件较大，压缩包文件较多。
数据结构与算法(Python版) | (7) 队列、列表OJ作业
12-21
OJ地址 1. 有序队列 def func(S): min_str = S #记录最小的字符串 for i in range(len(S)): #遍历字符串的长度 S = S[-1] + S[:-1] #每次把最后一个字符放在第一个位置 并拼接上剩余的字符 if S < min_str: #字符串可以直接比较大小 min_str = S return min_str S = eval(input()) #输入是"abc" eval可以取出""内部的字符串 得到abc pri
队列的实现以及一部分队列(oj)
qq_61273847的博客
04-05 493
前言：通过不断深入学习在上篇我们完成栈的实现。这篇主讲队列的实现以及队列和栈的oj题。 队列的实现前言：通过不断深入学习在上篇我们完成栈的实现。这篇主讲队列的实现以及队列和栈的oj题。一级目录 队列二级目录 栈的oj三级目录 队列的oj 一级目录 队列 二级目录 栈的oj 三级目录 队列的oj 队列大体图片如下 下面我们进行动画演示队列的进入与删除： ...
栈和队列常见oj题
weixin_59551524的博客
02-16 735
栈和队列 栈是先进后出（在栈顶进行删除和插入），所以你可以用在一些特殊的地方，比如逆序打印链表等等。 比如判断栈出数据的顺序，中缀表达式 转 后缀表达式 （后缀表达式也叫作逆波兰表达式） 现将转换成后缀表达式，通过这个表达式去计算。那么如何去转换成后缀表达式 需要用到栈 栈中的一些方法，可以查看api，比较常用的：peek,pop,push,isEmpty，search public static void main(String[] args) { MyStack s
栈和队列（OJ题思路分析+图解）
qq_54469537的博客
10-03 590
针对栈和队列一些相关OJ题的详细思路分析以及图解+完整代码
栈和队列经典OJ题
MEANSWER的博客
10-05 447
栈和队列经典OJ题1. LeetCode第225题---用队列实现栈2. LeetCode第232题---用栈实现队列3. LeetCode第20题---有效的括号4. LeetCode第150题---逆波兰表达式5. LeetCode第155题---最小栈6. 牛客网剑指offer21题---栈的压入、弹出序列 1. LeetCode第225题—用队列实现栈 链接: https://leetcode-cn.com/problems/implement-stack-using-queues/ 题解：用队列
【OJ算法训练】03__九月__队列
aloong的半山农场
10-18 188
队列 参考资料，以下内容来自CSDN大佬： 队列基本操作_zhang21722668的博客-CSDN博客_队列 数据结构系列－队列的基本操作_lin20080410的专栏-CSDN博客_队列 ... ... 定义 1. 只允许在一端进行插入数据操作，在另一端进行删除操作的特殊线性表； 2. 进行插入操作的一端称为队尾(入队列)，进行删除操作的一端称为队头(出队列)； 3. 队列遵循“先进先出”(FIFO)原则。 实现方式 顺序队列 数组实现，比如有一个ｎ个元素的队列，数组下标0的一端是队
oj教程--队列
weixin_30729609的博客
12-21 210
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 转载于:https://www.cnblogs.com/daxiang2008/p/10155925.html...
合肥工业大学oj 1148 队列
lalala_HFUT的博客
02-25 507
//这是一个数学问题， //注意到如果队列中去掉最矮的一个人，会使对数减少1（最矮的在队列两侧）或2（最爱的人在队列中） //根据这个规律dp #include&lt;iostream&gt; using namespace std; int n, m; int main(){ while(true){ cin &gt;&gt; n &gt;&gt; m; if(n ==...
一本通 oj题库 测试数据
最新发布
06-23
一本通 OJ 题库的测试数据，通常是用来验证提交的代码在各种情况下的正确性。测试数据可以分为两种类型，手动和自动。 手动测试数据是由题目的出题人根据题意和数据范围设计的一组数据，用来检测程序的正确性和运行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值