一、队列的概念及结构
队列:只允许在一端进行插入数据操作, 在另一端进行删除 数据操作的特殊线性表,队列具有先进先出FIFO(First In First Out)
入队列:进行插入操作的一端称为队尾;
出队列:进行删除操作的一端称为队头。
//test.c
#include "Stack.h"
#include "Queue.h"
void TestStack1()
{
ST st;
StackInit(&st);
StackPush(&st, 1);
StackPush(&st, 2);
StackPush(&st, 3);
StackPush(&st, 4);
StackPop(&st);
StackPop(&st);
StackPop(&st);
StackPop(&st);
//StackPop(&st);
//printf("%d", StackTop(&st));
StackDestroy(&st);
}
void TestStack2()
{
ST st;
StackInit(&st);
StackPush(&st, 1);
StackPush(&st, 2);
StackPush(&st, 3);
StackPush(&st, 4);
printf("%d ", StackTop(&st));
StackPop(&st);
printf("%d ", StackTop(&st));
StackPop(&st);
StackPush(&st, 5);
StackPush(&st, 6);
while (!StackEmpty(&st))//输出数据
{
printf("%d ", StackTop(&st));
StackPop(&st);
}
StackDestroy(&st);
}
void TestQueue1()
{
Queue q;
QueueInit(&q);
QueuePush(&q, 1);
QueuePush(&q, 2);
QueuePush(&q, 3);
QueuePush(&q, 4);
QueuePop(&q);
QueuePop(&q);
QueuePop(&q);
QueuePop(&q);
//QueuePop(&q);
//printf("%d\n", QueueFront(&q));
//printf("%d\n", QueueBack(&q));
QueuePush(&q, 10);
QueuePush(&q, 20);
QueueDestroy(&q);
}
void TestQueue2()
{
Queue q;
QueueInit(&q);
QueuePush(&q, 1);
QueuePush(&q, 2);
QDataType front = QueueFront(&q);
printf("%d ", front);
QueuePop(&q);
QueuePush(&q, 3);
QueuePush(&q, 4);
while (!QueueEmpty(&q))
{
QDataType front = QueueFront(&q);
printf("%d ", front);
QueuePop(&q);
}
printf("\n");
}
int main()
{
//TestStack2();
TestQueue2();
return 0;
}
//Queue.h
#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
typedef int QDataType;
typedef struct QueueNode
{
struct QueueNode* next;
QDataType data;
}QueueNode;
typedef struct Queue
{
QueueNode* head;
QueueNode* tail;
// size_t _size;
}Queue;
//void QueueInit(QueueNode** pphead, QueueNode** pptail);
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);
int QueueSize(Queue* pq);
bool QueueEmpty(Queue* pq);
#include<assert.h>
#include<stdbool.h>
typedef int QDataType;
typedef struct QueueNode
{
struct QueueNode* next;
QDataType data;
}QueueNode;
typedef struct Queue
{
QueueNode* head;
QueueNode* tail;
}Queue;
void QueueInit(Queue* pq)
{
assert(pq);
pq->head=NULL;
pq->tail=NULL;
}
void QueueDestory(Queue* pq)
{
assert(pq);
QueueNode* cur=pq->head;
while(cur!=NULL)
{
QueueNode* next=cur->next;//定义当前结点的下一个结点
free(cur);//删掉结点
cur=next;//往下走
}
pq->head=pq->tail=NULL;//置空
}
//进栈,队尾进
void QueuePush(Queue* pq,QDataType x)
{
assert(pq);
QueueNode* newnode=(QueueNode*)malloc(sizeof(QueueNode));
newnode->data=x;
newnode->next=NULL;// newnode初始化
//队列为空
if(pq->head=NULL)
{
pq->head=pq->tail= newnode;//newnode为队头也为队尾
}
else
{
pq->tail->next= newnode;//队尾指向newnode
pq->tail= newnode;//newnode变为新的tail
}
}
//出栈,队头出
void QueuePop(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));//保证pop的时候一定有数据
QueueNode* next=pq->head->next;
free(pq->head);
pq->head=next;
if(pq->head==NULL)//为空,处理完了,链表删完了
{
pq->tail=NULL;
}
}
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;
}
int QueueSize(Queue* pq);
{
assert(pq);
int n=0;
QueueNode* cur=pq->head;
while(cur)
{
++n;//大小加1
cur=cur->next;//往下走
}
return n;
}
bool QueueEmpty(Queue* pq)//判断队列是不是为空
{
assert(pq);//判断结构体不为空
return pq->head==NULL;
}
二、循环队列(数组/链表)
1、符合先进先出;2、空间大小固定。
重点:循环队列无论使用数组实现还是链表实现,都要多开一个空间,也就意味着要是一个存k个数据的循环队列,要开k+ 1个空间,否则无法实现判空和判满。若不多开一个空间的话 front == tail 无法判断队列是空还是满。
front==tail 空 (tail+1)%(k+1)==front 满 (tail->next==front)
三、例题
1.用队列实现栈(力扣)
不能改变队列结构,只能调用队列提供的接口函数实现。①入数据,往不为空的队列入,保持另一个队列为空;②出数据的时候,依次出队头的数据,转移另一个队列保存。只剩最后一个值,pop掉。
typedef int QDataType;
typedef struct QueueNode
{
struct QueueNode* next;
QDataType data;
}QueueNode;
typedef struct Queue
{
QueueNode* head;
QueueNode* tail;
}Queue;
typedef struct {
Queue q1;
Queue q2;
} MyStack;//没有typedef就是变量,有typedef就是结构体
void QueueInit(Queue* pq)
{
assert(pq);
pq->head = pq->tail = NULL;
}
void QueueDestory(Queue* pq)
{
assert(pq);
QueueNode* cur = pq->head;
while (cur)
{
QueueNode* next = cur->next;
free(cur);
cur = next;
}
pq->head = pq->tail = NULL;
}
// 队尾入
void QueuePush(Queue* pq, QDataType x)
{
assert(pq);
QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
if (newnode == NULL)
{
printf("malloc fail\n");
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;
}
}
// 队头出
void QueuePop(Queue* pq)
{
assert(pq);
assert(pq->head);
// 1、一个
// 2、多个
if (pq->head->next == NULL)
{
free(pq->head);
pq->head = pq->tail = NULL;
}
else
{
QueueNode* next = pq->head->next;
free(pq->head);
pq->head = next;
}
}
QDataType QueueFront(Queue* pq)
{
assert(pq);
assert(pq->head);
return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
assert(pq);
assert(pq->head);
return pq->tail->data;
}
int QueueSize(Queue* pq)
{
assert(pq);
int size = 0;
QueueNode* cur = pq->head;
while (cur)
{
++size;
cur = cur->next;
}
return size;
}
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->head == NULL;
}
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);
int QueueSize(Queue* pq);
bool QueueEmpty(Queue* pq);
MyStack* myStackCreate() {
MyStack* st=(MyStack*)malloc(sizeof(MyStack));
QueueInit(&st->q1);
QueueInit(&st->q2);
return st;
}
void myStackPush(MyStack* obj, int x) {
if(!QueueEmpty(&obj->q1))//q1不为空就往q1里push
{
QueuePush(&obj->q1,x);
}
else
{
QueuePush(&obj->q2,x);//否则往q2里push
}
}
int myStackPop(MyStack* obj) {
//默认q1为空q2不为空
Queue* emptyQ=&obj->q1;
Queue* nonemptyQ=&obj->q2;
if(!QueueEmpty(&obj->q1))
{
emptyQ=&obj->q2;
nonemptyQ=&obj->q1;//默认错误q1不为空q2为空
}
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) {
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);
*/
2. 用栈实现队列(力扣)
向pushST入数据,从popST出数据。pop栈里没有数据,要从push栈里导过来,popST中的数据就符合先进先出了。pushST不为空就往popST里导。
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}ST;
void StackInit(ST* ps);
void StackDestory(ST* ps);
void StackPush(ST* ps,STDataType x);
void StackPop(ST* ps);
STDataType StackTop(ST* ps);//取栈顶数据
int StackSize(ST* ps);
bool StackEmpty(ST* ps);//判断栈是不是为空
void StackInit(ST* ps)
{
assert(ps);//结构体的指针不能为空
ps->a=NULL;
ps->top=0;//初始化时,top给的是0,意味着top指向栈顶数据的下一个
//ps->top=-1 初始化时,top给的是-1,意味着top指向栈顶数据
ps->capacity=0;
}
//销毁栈
void StackDestory(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)//栈满
{
int newCapacity=ps->capacity==0?4:ps->capacity*2;//增容,若capacity如初始化时为0,扩容四个空间,否则扩容到原来的2倍
STDataType* tmp=realloc(ps->a,sizeof(STDataType)*newCapacity); //realloc有空间就扩容,没有就相当于malloc
if(tmp==NULL)
{
printf("realloc fail\n");
exit(-1);//增容失败
}
ps->a=tmp;//开辟空间成功
ps->capacity=newCapacity;
}
ps->a[ps->top]=x;//先把数据放在top位置
ps->top++;//指向下一个位置
}
//出栈
void StackPop(ST* ps)
{
assert(ps);
assert(ps->top>0);//表示还有数据,不为空
ps->top--;
}
//取栈顶数据
STDataType StackTop(ST* ps)
{
assert(ps);
assert(!StackEmpty(ps));//表示还有数据,不为空
return ps->a[ps->top-1];
}
//栈的大小
int StackSize(ST* ps)
{
assert(ps);
return ps->top;
}
//判断栈是不是为空
bool StackEmpty(ST* ps)
{
assert(ps);
return ps->top==0;//为空返回真
}
typedef struct {
ST pushST;
ST popST;
} MyQueue;
MyQueue* myQueueCreate() {
MyQueue* q=(MyQueue*)malloc(sizeof(MyQueue));
StackInit(&q->pushST);
StackInit(&q->popST);
return q;
}
void myQueuePush(MyQueue* obj, int x) {
StackPush(&obj->pushST,x);//不管有没有数据直接入,向pushST入数据,从popST出数据
}
int myQueuePop(MyQueue* obj) {
if(StackEmpty(&obj->popST))//pop栈里没有数据,要从push栈里导过来,popST中的数据就符合先进先出了
{
while(!StackEmpty(&obj->pushST))//pushST不为空就往popST里导
{
StackPush(&obj->popST,StackTop(&obj->pushST));//栈顶数据依次导过来,返回的是栈顶元素
StackPop(&obj->pushST);//pushST删掉导出的数据
}
}
int front=StackTop(&obj->popST);//pop不为空,变量先保存起来再删掉
StackPop(&obj->popST);//删掉元素
return front;
}
int myQueuePeek(MyQueue* obj) {
if(StackEmpty(&obj->popST))//pop栈里没有数据,要从push栈里导过来,popST中的数据就符合先进先出了
{
while(!StackEmpty(&obj->pushST))//pushST不为空就往popST里导
{
StackPush(&obj->popST,StackTop(&obj->pushST));//栈顶数据依次导过来,返回的是栈顶元素
StackPop(&obj->pushST);//pushST删掉导出的数据
}
}
return StackTop(&obj->popST);//只取队头数据,不用删除
}
bool myQueueEmpty(MyQueue* obj) {
return StackEmpty(&obj->pushST)&&StackEmpty(&obj->popST);//两个都为空才为空
}
void myQueueFree(MyQueue* obj) {
StackDestory(&obj->pushST);
StackDestory(&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.设计循环队列(力扣)
typedef struct {
int*a;
int front;
int tail;
int k;//环形队列存放数据的大小
} MyCircularQueue;
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);//声明
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* cq=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
cq->a=(int*)malloc(sizeof(int)*(k+1));
cq->front=cq->tail=0;
cq->k=k;//结构体初始化
return cq;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
if (myCircularQueueIsFull(obj))
return false;
obj->a[obj->tail]=value;//把数据存放在tail处
++obj->tail;//tail往后
obj->tail%=(obj->k+1);//判断数据是不是走到第k+1个,如果是的话,下一次tail变为第一个
return true;
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
return false;
++obj->front;//tail往后
obj->front%=(obj->k+1);//判断数据是不是走到第k+1个,如果是的话,下一次tail变为第一个
return true;
}
int myCircularQueueFront(MyCircularQueue* obj) {//取队头数据
if(myCircularQueueIsEmpty(obj))
return -1;
return obj->a[obj->front];
}
int myCircularQueueRear(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
return -1;
if(obj->tail==0)//tail在第一个位置
{
return obj->a[obj->k];//最后一个值即为队尾的值
}
else
{
return obj->a[obj->tail-1];//普通情况下是tail的前一个
}
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
return obj->front==obj->tail;
}
bool myCircularQueueIsFull(MyCircularQueue* obj) {
return (obj->tail+1)%(obj->k+1)==obj->front;
}
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);
*/