数据结构：队列 || oj(l两个队列实现栈)

最新推荐文章于 2024-09-27 23:56:15 发布
最新推荐文章于 2024-09-27 23:56:15 发布
阅读量868 收藏 8
点赞数 30
文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76821799/article/details/136372528
版权

@[TOC](数据结构：队列 || oj(l两个队列实现栈))

一、队列的概念

1.什么是队列？
//先说一下，队列跟栈一样都是很重要的数据结构，重要的不是说这个数据结构怎么实现，重要的是结构的优势！
//栈：是先入先出，选的最好的是底层用数组，来实现，可以栈顶入，栈顶出，复杂度都是O(1),在就是CPU高速缓存，缓存线取数据（好像一般是64个字节），取数据效率高！，比链表好一点，用链表的话，单链表头做栈顶，用做压数据，和取数据都可以！
//队列：这种数据结构的要求是：先入先出，不能用数组来实现，原因是：如果把数组后面当尾巴，队尾入数据这个可以，队头出数据要挪动数据，时间复杂度是O(n)，因此用链表来实现队列!
2.队列的概念
//队列：只允许在一段插入数据操作，在另一端删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)
// 入队列：进行插入操作的一端称为队尾
// 出队列：进行删除操作的一端称为队头
//队尾入，队头出
1

//队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。
1
//用链表实现队列，链表头用作队列头取数据，链表尾用作队列尾巴，插（放）数据！
//定义节点：
typedef int QDataType ;
typedef struct QListNode{
  int val;
  struct QListNode* next;
}QLNode;
//这样定义一个链表有个问题，头删当然可以，尾插呢？时间复杂度是O(n),那么可以定义一个头指针（head），一个尾指针(tail)来解决这个问题,还要考虑统计在队列中数据的个数，因此在定义一个int Size;那么把这些数据放在一个结构体中，就很好的解决了这个问题！因此：
typedef struct Queue{
  QLNode* head;
  QLNode* tail;
  int Size;
}Queue;
//这样这个栈就定义好了，这样定义的好处是：只要传Queue的地址，就可以改变head和tail和Size的值了，如果单独写，那么改变head的内容，则要QLNode** 来接受，可以规避这一点，还有就是头，尾都有标记，随便可以搞！
//下面来实现队列
//定义队列

//存储队列的数据

typedef int QDataType;

typedef struct QListNode {
	QDataType val;
	struct QListNode* next;
}QLNode;


//用结构体来存储队头，队尾，数据个数

typedef struct Queue {
	QLNode* head;
	QLNode* tail;
	int size;    //存储数据的个数
}Queue;

//实现的接口如下，虽然有些接口没用到，但是以后肯定用！
//初始化
void QueueInit(Queue* pq);
//销毁
void QueueDestory(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 QueueDestory(Queue* pq) {
	assert(pq);
	QLNode* cur = pq->head;
	while (cur) {
		QLNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}

//队尾入数据，尾插法！
//分两种情况：初始化时：head=tail=NULL;
//1.那么head为空，则直接申请节点给就行！
//2.其它，正常尾插即可!

//队尾入数据
void QueuePush(Queue* pq, QDataType x) {
	assert(pq);
	QLNode* newnode =(QLNode*)malloc(sizeof(QLNode));
	newnode->next = NULL;
	newnode->val = x;
	if (pq->head == NULL) {
		pq->head = pq->tail = newnode;
	}
	else {
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	pq->size++;
}

//队头删数据，头删
//考虑，因为头删的话，要存下一个节点，其实最坏情况下一个节点为NULL，也就是只有一个节点，那么head能置空，tail是一个问题，因此分开写！
//1.没有节点，直接断言assert;
//2.一个节点，直接释放，给head,tail置NULL；
//3.至少两个节点：删一个，下一个肯定不问NULL，直接正常情况删除！

//队头出数据
void QueuePop(Queue* pq) {
	//头删
	assert(pq);
	//头指针为空，没有数据
	assert(pq->head);

	//一个节点
	//在单链表的头删中，可以直接写
	//在栈中特殊处理，因为一个节点的时候，要把tail置NULL
	if (pq->head->next == NULL) {
		free(pq->head);
		pq->head = NULL;
		pq->tail = NULL;
	}
	//其它
	else {
		QLNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->size--;

}

//获取队头数据

//获取队头数据
QDataType QueueFront(Queue* pq) {
	assert(pq);
	assert(pq->head);
	return pq->head->val;
}

//获取队尾数据

//获取队尾数据
QDataType QueueBack(Queue* pq) {
	assert(pq);
	assert(pq->tail);
	return pq->tail->val;
}

//判空

//判空
bool QueueEmpty(Queue* pq) {
	assert(pq);
	return pq->size == 0;
}

//获取元素个数

//获取元素个数
int QueueSize(Queue* pq) {
	assert(pq);
	return pq->size;
}

//下面为整个代码!
//Queue.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
//存储队列的数据

typedef int QDataType;

typedef struct QListNode {
	QDataType val;
	struct QListNode* next;
}QLNode;


//用结构体来存储队头，队尾，数据个数

typedef struct Queue {
	QLNode* head;
	QLNode* tail;
	int size;    //存储数据的个数
}Queue;


//初始化
void QueueInit(Queue* pq);
//销毁
void QueueDestory(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);

//Queue.c

#include "Queue.h"

//初始化
void QueueInit(Queue* pq) {
	assert(pq);
	pq->head = pq->tail= NULL;
	pq->size = 0;
}

//销毁
void QueueDestory(Queue* pq) {
	assert(pq);
	QLNode* cur = pq->head;
	while (cur) {
		QLNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}

//队尾入数据
void QueuePush(Queue* pq, QDataType x) {
	assert(pq);
	QLNode* newnode =(QLNode*)malloc(sizeof(QLNode));
	newnode->next = NULL;
	newnode->val = x;
	if (pq->head == NULL) {
		pq->head = pq->tail = newnode;
	}
	else {
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	pq->size++;
}
//队头出数据
void QueuePop(Queue* pq) {
	//头删
	assert(pq);
	//头指针为空，没有数据
	assert(pq->head);

	//一个节点
	//在单链表的头删中，可以直接写
	//在栈中特殊处理，因为一个节点的时候，要把tail置NULL
	if (pq->head->next == NULL) {
		free(pq->head);
		pq->head = NULL;
		pq->tail = NULL;
	}
	//其它
	else {
		QLNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->size--;

}
//获取队头数据
QDataType QueueFront(Queue* pq) {
	assert(pq);
	assert(pq->head);
	return pq->head->val;
}
//获取队尾数据
QDataType QueueBack(Queue* pq) {
	assert(pq);
	assert(pq->tail);
	return pq->tail->val;
}
//判空
bool QueueEmpty(Queue* pq) {
	assert(pq);
	return pq->size == 0;
}
//获取元素个数
int QueueSize(Queue* pq) {
	assert(pq);
	return pq->size;
}

//Test.c

#include "Queue.h"

int main() {
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	while (!QueueEmpty(&q)) {
		int front = QueueFront(&q);
		printf("%d ", front);
		QueuePop(&q);
	}
	return 0;
}

二、两个队列实现栈问题

1
//实现思路
//怎么入栈？
//怎么出栈？

1

//出栈：假设一个队列入 1 2 3 4，那么要求是出4，4在尾巴，怎么出，那么把1,2,3出队列，入一个空的队列，然后在出第一个队列的数据！
//入栈：如果队列不为空，则入数据
//下面实现整个接口

//创建栈

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

//动态申请创建栈

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

//入栈

void myStackPush(MyStack* obj, int x) {
    //队列不为空的入
    if(!QueueEmpty(&obj->q1)){
        QueuePush(&obj->q1,x);
    }
    else{
        QueuePush(&obj->q2,x);
    }
}

//出栈

int myStackPop(MyStack* obj) {
    //先把不为空的队列的size-1个元素移到为空的队列
    //然后出队列
    Queue* NoEmptyQueue = &obj->q1;
    Queue* EmptyQueue = &obj->q2;
    if(QueueEmpty(&obj->q1)){
        NoEmptyQueue = &obj->q2;
        EmptyQueue = &obj->q1;
    }
    while(QueueSize(NoEmptyQueue)>1){
        int front = QueueFront(NoEmptyQueue);
        QueuePop(NoEmptyQueue);
        QueuePush(EmptyQueue,front);
    }
    int front = QueueFront(NoEmptyQueue);
    QueuePop(NoEmptyQueue);
    return front;
}

//获取栈顶数据
//这个体现接口的优势，在队列中实现了取队列尾的数据！
//直接调用

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) {
    QueueDestory(&obj->q1);
    QueueDestory(&obj->q2);
    free(obj);
}

//下面是整体的代码

typedef int QDataType;

typedef struct QListNode {
	QDataType val;
	struct QListNode* next;
}QLNode;


//用结构体来存储队头，队尾，数据个数

typedef struct Queue {
	QLNode* head;
	QLNode* tail;
	int size;    //存储数据的个数
}Queue;

//初始化
void QueueInit(Queue* pq) {
	assert(pq);
	pq->head = pq->tail= NULL;
	pq->size = 0;
}

//销毁
void QueueDestory(Queue* pq) {
	assert(pq);
	QLNode* cur = pq->head;
	while (cur) {
		QLNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
	pq->size = 0;
}

//队尾入数据
void QueuePush(Queue* pq, QDataType x) {
	assert(pq);
	QLNode* newnode =(QLNode*)malloc(sizeof(QLNode));
	newnode->next = NULL;
	newnode->val = x;
	if (pq->head == NULL) {
		pq->head = pq->tail = newnode;
	}
	else {
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	pq->size++;
}
//队头出数据
void QueuePop(Queue* pq) {
	//头删
	assert(pq);
	//头指针为空，没有数据
	assert(pq->head);
	//一个节点
	if (pq->head->next == NULL) {
		free(pq->head);
		pq->head = NULL;
		pq->tail = NULL;
	}
	//其它
	else {
		QLNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->size--;
}
//获取队头数据
QDataType QueueFront(Queue* pq) {
	assert(pq);
	assert(pq->head);
	return pq->head->val;
}
//获取队尾数据
QDataType QueueBack(Queue* pq) {
	assert(pq);
	assert(pq->tail);
	return pq->tail->val;
}
//判空
bool QueueEmpty(Queue* pq) {
	assert(pq);
	return pq->size == 0;
}
//获取元素个数
int QueueSize(Queue* pq) {
	assert(pq);
	return pq->size;
}

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


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

void myStackPush(MyStack* obj, int x) {
    //队列不为空的入
    if(!QueueEmpty(&obj->q1)){
        QueuePush(&obj->q1,x);
    }
    else{
        QueuePush(&obj->q2,x);
    }
}

int myStackPop(MyStack* obj) {
    //先把不为空的队列的size-1个元素移到为空的队列
    //然后出队列
    Queue* NoEmptyQueue = &obj->q1;
    Queue* EmptyQueue = &obj->q2;
    if(QueueEmpty(&obj->q1)){
        NoEmptyQueue = &obj->q2;
        EmptyQueue = &obj->q1;
    }
    while(QueueSize(NoEmptyQueue)>1){
        int front = QueueFront(NoEmptyQueue);
        QueuePop(NoEmptyQueue);
        QueuePush(EmptyQueue,front);
    }
    int front = QueueFront(NoEmptyQueue);
    QueuePop(NoEmptyQueue);
    return front;
}

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) {
    QueueDestory(&obj->q1);
    QueueDestory(&obj->q2);
    free(obj);
}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/

完结!

 气质、小青年！
关注
【OJ】---L---对象数组输入与输出
u012369143的专栏
06-27 673
题目要求如下： --------------------------------------------------------------------------------------------------------------------------- 代码如下：
第15周 oj Problem L: 字符串替换（串）
秋刀山名鱼、
12-12 1238
问题及代码： /*Copyright(c)2016,烟台大学计算机学院 all rights reserved. 作者:曹欣宇 指导教师：贺利坚 完成日期:2016年12月12日 题目描述 编写一个C程序实现将字符串中的所有"you"替换成"we" 输入 输入包含多行数据 每行数据是一个字符串，长度不超过1000 数据以EOF结束 输出 对于输入的每一行，输出替换后的字
数据结构：栈与队列OJ题
2401_86551514的博客
08-08 1464
前面讲了栈和队列的基础知识，今天来巩固一下加深理解，这里说明一下，因为现在都是在用C语言写，这些OJ题里都要用到前面实现栈和队列的代码，每道题我都会加上前面的链接方便查看。
栈和队列OJ题：LeetCode--232.用栈实现队列
Yikefore的博客
05-20 1439
LeetCode--232.用栈实现队列：详细题解以及图解和完整代码。
[数据结构] 用两个栈实现队列详解
weixin_67596609的博客
03-22 4043
在数据结构中，栈和队列是较为常见的两种数据结构。。那怎么用栈去实现队列呢？此问题在面试中也是高频出现的问题。本篇文章会给出详细解释。
【数据结构】队列OJ：两个栈实现队列、两个队列实现栈、实现最小值栈
qq_61903414的博客
12-22 324
栈的特点是先进后出，而队列的特点是先进先出。用栈实现队列的时候，我们定义一个栈把他作为专门用于入队的栈，然后另一个栈做为出队的栈。
【数据结构】栈和队列超详细讲解
Become Mad的博客
05-27 2146
我们已经学习了顺序表、链表、数组等数据结构，今天我们再来认识一下栈和队列两种新的数据结构，一起来看看吧~
数据结构：队列 和 栈 的详解
潜心钻研技术
09-12 614
文章目录栈栈的结构和概念栈的实现栈的实现：栈的一些引用括号匹配问题队列队列的概念和结构队列的实现此外还要介绍一种队列：循环队列 栈 栈的结构和概念 栈 ：一种特殊的线性表，其中只允许在固定的一端进行插入和删除元素。进行数据插入和删除操作的一段称为栈顶，另一端称为栈底 。栈中的元素遵循先进后出的原则。 压栈：栈的插入操作叫做 进栈/入栈/压栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈，出数据也在栈顶。 栈的实现 栈的实现一般可以使用数组或者链表，但是数组的结构要更优一点。因为数组在
数据结构:栈和队列详解和相关oj题
qq_62274623的博客
06-13 1278
栈队列超详细解答,欢迎阅读
【数据结构】队列详解 && 栈和队列OJ题 —— 用队列实现栈、用栈实现队列、设计循环队列
StackFrame
11-16 1123
队列的概念和结构讲解、C语言实现队列、OJ题 —— 用队列实现栈、用栈实现队列、设计循环队列
【C语言】实现数据结构——栈，队列
weixin_45423515的博客
05-18 2253
栈和队列都常用的数据结构，这里使用C语言实现栈和队列， 一、栈 栈：是一种特殊的线性表，其只允许在一端出数据和入数据，插入数据和删除数据的一端加栈顶，另一端叫栈底。其数据遵守先进后出的原则（Last in First out）。 因为这个特点那么如果进入一段数据是 1 2 3 4 5，那么其出数据就是反的 5 4 3 2 1。 压栈(push):往栈顶插入数据。 出栈(pop):把数据在栈顶删除。 实现： typedef int STdatatype; typedef...
数据结构C语言篇《三》栈和队列概念，模拟函数实现，以及相关OJ面试题
愿你有青春亦可奔赴
05-22 1165
#pragma once typedef int DataType; typedef struct Stcak { DataType *arr; int capacity; //容量大小 int size; //有效元素个数---栈顶 }Stack; //栈的初始化 void StackInit(Stack *ps); //入栈 void StackPush(Stack *ps, DataType data); //出栈 void StackPop(Stack *ps); //获取栈顶元
数据结构 - 队列 实现与常见题型（C语言）
qq_61386381的博客
05-21 1001
目录 前言： 队列的概念及结构 队列的实现 队列的定义 接口函数 实现接口函数 完整代码 Queue.h Queue.c 栈与队列的OJ练习 T1、用队列实现栈 T2、用栈实现队列 T3、设计循环队列 栈和队列的用途 前言： 队列的概念及结构 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 ............
数据结构---栈和队列OJ习题
qq_35297945的博客
01-19 399
1 括号匹配问题 1.1 题目介绍 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。 有效字符串需满足：     左括号必须用相同类型的右括号闭合。     左括号必须以正确的顺序闭合。 注意:空字符串可被认为是有效字符串。 示例 1: 输入: “([])” 输出: true 示例 3: 输入: “(][)” 输出: false 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/valid-paren
（JAVA）队列 和 符号表 两种数据结构的实现
最新发布
ZunXin_2580的博客
09-27 606
如果想要清晰的认识队列或者符号表是怎样的结构，那么就来看看这篇文章吧！！
[数据结构] 二叉树题目(一)
nmbg11的博客
09-27 459
leetcode有关二叉树的相关题目. 翻转二叉树. 相同的树. 对称二叉树.
数据结构（Map、Set、搜索树）
wuweixiaoyue的博客
09-27 790
概念优势：查找元素时可以直接砍去一半的值，达到 log(N)示例：此时如果要找4，因为4比6小，所以要去6的左边找，此时因为4比3大，所以要去3的右树找，最终找到了如果找到了就返回，如果直到全部找完遇到null了也没找到，说明该搜索树下根本就没有该元素有序问题：二叉搜索树的中序遍历是有序的概念：Map和Set是专门用来进行搜索的容器或数据结构Set是纯key模型，Map是 Key-Value 模型Set最大的功能就是对集合中的元素进行去重接口实例化。
浙大数据结构：06-图3 六度空间
qq_74924951的博客
09-27 516
bfs稍难题
C语言实现数据结构：栈的理解与应用
文中给出了一段C语言的代码示例，展示了如何定义和初始化一个基于数组的栈结构： ```c typedef int STDataType; typedef struct Stack { STDataType *a; int top; int capacity; } ST; // typedef定义简化代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值