栈和队列oj题

最新推荐文章于 2023-08-12 20:49:37 发布
最新推荐文章于 2023-08-12 20:49:37 发布
阅读量222 收藏 4
点赞数 4
分类专栏： 数据结构 文章标签： leetcode 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67595436/article/details/126242512
版权

目录

225. 用队列实现栈

描述

代码

 232. 用栈实现队列

描述

代码

622. 设计循环队列

描述

代码

补录一些概念题目

结束语

225. 用队列实现栈

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

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。
 

注意：

你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
 

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/implement-stack-using-queues

描述

代码


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

//能用单链表解决问题就可以用单链表 -- 没必要使用双向循环链表，这属于有点小题大做了

typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;

//再定义一个节点来存放两个指针，方便后面操作
typedef struct Queue
{
	//尾指针
	QNode* tail;
	//头指针
	QNode* head;
	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 = 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;	//要改变什么就需要什么的指针，这里置空就可以了
}

//入队列 -- 根据队列的性质 只尾插
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	else
	{
		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->tail = pq->head = NULL;
	}
	else
	{
		QNode* del = pq->head;
		pq->head = pq->head->next;

		free(del);
		del = NULL;
	}

	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);

	//这样写就变为O(N)级别了 为此需要稍作修改
	//QNode* cur = pq->head;
	//int n = 0;
	//while (cur)
	//{
	//	++n;
	//	cur = cur->next;
	//}

	//return n;

	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))    //如果q1不为空就继续放数据
    {
        QueuePush(&obj->q1 , x);
    }
    else
    {
        QueuePush(&obj->q2 , x);
    }

}

int myStackPop(MyStack* obj) {
    Queue* Empty = &obj->q1;
    Queue* nonEmpty = &obj->q2;
    if(!QueueEmpty(&obj->q1))   //假设一个为空，再后面判断赋值，使得对应的指针为空
    {
        Empty = &obj->q2;
        nonEmpty = &obj->q1;
    }

    //把非空的队列的数据倒到空的队列中去 -- 只要倒n-1个就行了，最后一个弹出来
    while(QueueSize(nonEmpty) > 1)
    {
        QueuePush(Empty ,QueueFront(nonEmpty));
        QueuePop(nonEmpty);
    }

    int top = QueueFront(nonEmpty);
    QueuePop(nonEmpty); //top已经保留了数据，弹出去不影响
    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) {
//这里要单独把释放，因为它们开辟的空间仅仅释放obj是释放不掉的
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);

    free(obj);
}

 232. 用栈实现队列

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

实现 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false
说明：

你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。
 

示例 1：

输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false
 

提示：

1 <= x <= 9
最多调用 100 次 push、pop、peek 和 empty
假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）
 

进阶：

你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/implement-queue-using-stacks

 

描述

 

代码


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


typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;		//数据
	int capacity;	//空间容量
}ST;

//初始化
void StackInit(ST* ps);

//销毁
void StackDestroy(ST* ps);

//入栈
void StackPush(ST* ps , STDataType x);	//根据栈的概念 栈只有一个地方可以插入

//出栈
void StackPop(ST* ps);

//访问Top位置
STDataType StackTop(ST* ps);

//检查是否为空
bool StackEmpty(ST* ps);

//查看数据数量
int StackSize(ST* ps);	//调用函数来实现 -- 数据结构建议不要直接访问结构数据，一定要通过函数接口访问
						//解耦 -- 高内聚，低耦合


//初始化
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

//销毁
void StackDestroy(ST* ps)
{
	assert(ps);

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

//入栈
void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	//扩容
	if (ps->top == ps->capacity)	//根据初始化的内容来判断
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}


	ps->a[ps->top] = x;
	ps->top++;

}

//出栈
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	--ps->top;
}

//访问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; //这里的top刚好是数据的下一个位置，自然就是数据个数
}



typedef struct {
    ST pushST;
    ST popST;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&obj->pushST);
    StackInit(&obj->popST);

    return obj;
}

void myQueuePush(MyQueue* obj, int x) {

    StackPush(&obj->pushST,x);    //把数据放到pushST里面，专门放数据

}

//额外写的一个接口函数，专门用来倒数据的
void PushTToPopST(MyQueue* obj)
{
    if(StackEmpty(&obj->popST))
    {
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST, StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }

    }

}

int myQueuePop(MyQueue* obj) {
    PushTToPopST(obj);

    int front = StackTop(&obj->popST);
    StackPop(&obj->popST);

    return front;
}

int myQueuePeek(MyQueue* obj) {

    PushTToPopST(obj);

    return StackTop(&obj->popST);

}

bool myQueueEmpty(MyQueue* obj) {

    return  StackEmpty(&obj->pushST)
        &&  StackEmpty(&obj->popST);
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->popST);
    StackDestroy(&obj->pushST);

    free(obj);
}

622. 设计循环队列

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/design-circular-queue

描述

 

代码

typedef struct {
    int* a;
    int front;  //头部
    int back;   //尾部
    int N;  //存储空间
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (int*)malloc(sizeof(int)*(k+1)); //多开一个数据空间
    obj->front = obj->back = 0;
    obj->N = k+1;   //实际空间长度

    return obj;
}

//这两个接口从下面移到了上面
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {

    return obj->front == obj->back; //当两个相等的时候就为空，因为back指的是下一个位置
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
 
        return  (obj->back+1)% obj->N == obj->front;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
        return false;
    
    obj->a[obj->back] = value;
    obj->back++;
    obj->back %= obj->N;    //控制back位置，到尾的时候就回到0的位置

    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {

    if(myCircularQueueIsEmpty(obj))
        return false;

    obj->front++;
    //控制front位置，假如到了空间尾以后，back回到0的位置
    obj->front %= obj->N;

    return true;
}

//返回队头的数据
int myCircularQueueFront(MyCircularQueue* obj) {
        if(myCircularQueueIsEmpty(obj))
            return -1;  //题目要求失败返回-1
        else
            return obj->a[obj->front];

}

//返回队尾的数据
int myCircularQueueRear(MyCircularQueue* obj) {
        if(myCircularQueueIsEmpty(obj))
            return -1;
        else
            return obj->a[(obj->back -1 +obj->N)% obj->N] ;   //返回前一个位置的数据，因为这里实现的back指向尾的后一个，但是要注意端点的情况
}



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

补录一些概念题目

下面有一道题目是与 int myCircularQueueRear(MyCircularQueue* obj) 这个接口相关的

 

选择查看答案 

3.D
4.B
5.B

结束语 

世事一场大梦，人生几度秋凉？

                                               苏轼《西江月》

清风玉骨
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
oj3335 数据结构实验之栈与队列八：栈的基本操作
qq_45666654的博客
05-13 1402
数据结构实验之栈与队列八：栈的基本操作 Description 堆栈是一种基本的数据结构。堆栈具有两种基本操作方式，push 和 pop。push一个值会将其压入栈顶，而 pop 则会将栈顶的值弹出。现在我们就来验证一下堆栈的使用。 Input 首先输入整数t（1 <= t <= 10），代表测试的组数，以后是 t 组输入。 对于每组测试数据，第一行输入两个正整数 m（1 <= m <= 100)、n（1 <= n <= 1000)，其中m代表当前栈的最大长度，n代表本组
两个队列模拟栈-OJ题
qq_58724706的博客
11-03 255
目录 题目描述 示例 提示 题目分析 结构体的创建 函数接口 void myStackPush(MyStack* obj, int x) int myStackPop(MyStack* obj) int myStackTop(MyStack* obj) bool myStackEmpty(MyStack* obj) void myStackFree(MyStack* obj) 完整代码 题目描述 请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种..
栈和队列OJ练习——栈实现队列，队列实现栈
qq_67611811的博客
08-26 585
栈与队列的数据存储方式完全不同，栈的数据遵循先进后出模式FILO，而队列为先进先出模式FIFO，要想使用栈的结构实现队列的数据增删模式，需要使用栈的性质并对其稍加巧用，就可以达到同队列的数据存储访问相同的效果。注意，本章中用栈实现队列所用到的栈函数，以及队列实现栈使用到的队列接口函数都在上一章模拟实现提及到，详情请参照上一章，链接在此数据结构——栈和队列_VelvetShiki_Not_VS的博客-CSDN博客。定义两个栈，一个用于临时存放压栈的数据，命名其为Push栈，再定义一个专用于出数据的栈Pop，当
队列的实现以及一部分队列(oj)
qq_61273847的博客
04-05 501
前言：通过不断深入学习在上篇我们完成栈的实现。这篇主讲队列的实现以及队列和栈的oj题。 队列的实现前言：通过不断深入学习在上篇我们完成栈的实现。这篇主讲队列的实现以及队列和栈的oj题。一级目录 队列二级目录 栈的oj三级目录 队列的oj 一级目录 队列 二级目录 栈的oj 三级目录 队列的oj 队列大体图片如下 下面我们进行动画演示队列的进入与删除： ...
LeetCode —— 栈和队列相关的oj题（含循环队列）
M的博客
04-13 880
LeetCode——栈和队列相关的oj题
程序设计基础 OJ 题库 NUIST
10-22
在OJ题库中，常见的数据结构包括数组、链表、栈、队列、树（二叉树、平衡树如AVL和红黑树等）、哈希表等。理解并熟练运用这些数据结构可以有效地组织和操作数据，实现高效的算法。 在NUIST的"程序设计基础"课程中，...
oj题.zip
最新发布
10-18
每一道题目都可能包含多种解题策略，如动态规划、贪心算法、回溯、深度优先搜索、广度优先搜索、链表操作、二叉树操作、字符串处理、图论以及基本的数据结构如数组、栈、队列、哈希表等。通过深入研究这些解决方案，...
南阳理工oj离线题库
05-14
2. 数据结构与算法：题库中的题目可能会涉及各种数据结构，如数组、链表、栈、队列、树、图等，以及各种算法，如排序、搜索、动态规划、贪心算法等。用户可以通过解答这些题目来巩固和提升这些基础知识。 3. 编程...
平顶山学院OJ试题离线版
05-14
2. **数据结构**：涉及数组、链表、栈、队列、树（如二叉树、AVL树、红黑树等）、图、哈希表等。掌握这些数据结构能帮助解冑复杂的问题，并优化程序的运行效率。 3. **操作系统**：涵盖进程管理、内存管理、文件...
LeetCode:LeetCode OJ 题库
05-17
4. **滑动窗口最大值（239）**：此题考察的是数组处理和滑动窗口的概念。任务是在一个数组中找到每个可能窗口的最大值。可以利用双端队列（deque）来实现，保持队列中元素的顺序，同时维护窗口内的最大值。 这些...
SDUT ACM OJ PTA 数据结构 栈和队列
林夕的博客
09-22 903
栈和队列
LeetCode ACM模式——栈与队列篇
zssxcj的博客
08-12 354
请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的。请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（在完成所有重复项删除操作后返回最终的字符串。在 S 上反复执行重复项删除操作，直到无法继续删除。返回一个表示表达式值的整数。会选择两个相邻且相同的字母，并删除它们。滑动窗口每次只向右移动一位。给出由小写字母组成的字符串。，请你返回其中出现频率前。，判断字符串是否有效。
牛客网暑期ACM多校训练营（第六场）A Singing Contest 队列 +简单模拟
qq_41668093的博客
08-05 215
链接：https://www.nowcoder.com/acm/contest/144/A 来源：牛客网   Singing Contest 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 262144K，其他语言524288K 64bit IO Format: %lld 题目描述 Jigglypuff is holding a singing contest. There...
小学生玩ACM----栈和队列
浩爷地带，你的地盘听我的....
08-04 3003
很多人都看过栈和队列了吧？那岂不是我没有说的意义了？那好，我就做这个记录，等我老了还可以给孙子学栈和队列，嘿嘿      栈和队列一个先进后出，一个先进先出，栈就是一个狗洞，你爬进去之后因为空间太小不许你翻身，所以想出来就的往后挪，当然要是有人用棍子顶住你菊花那你就出不去了，嘿嘿，队列就是你人品好一点，找到的这个狗洞的主人比较勤快，已经把洞挖通了，所以对面就是出口，但是你一进去之后狗狗就发现你了
ACM算法训练【模拟队列】
大河之犬的博客
04-26 318
【代码】ACM算法训练【模拟队列】
【实战】ACM 选手图解 LeetCode 用队列实现栈
用有趣有味的方式，学习有价值的编程知识。
02-23 277
图解 LeetCode 225：用队列实现栈。
优先队列详解
人景壶天
02-14 335
优先队列：顾名思义，首先它是一个队列，但是它强调了“优先”二字，所以，已经不能算是一般意义上的队列了，它的“优先”意指取队首元素时，有一定的选择性，即根据元素的属性选择某一项值最优的出队~ 百度百科上这样描述的： 　　优先级队列 是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素 　　优先队列的类定义　　 　　优先队列是0个或多个元素的集合,每个元素都有一个优先权或值
acm拿国奖的第二关：栈和队列
喜欢吃豆的博客
10-28 742
对栈和队列进行一个大概的讲述。
ACM.队列
abysswatcher1的博客
02-13 854
队列题目 一.
训练营OJ完整版1
08-03
训练营OJ完整版1

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

清风玉骨

爱了！

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

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

打赏作者

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

抵扣说明：

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

余额充值