栈和队列OJ题合集(包含循环队列的两种实现)
Posted 派小星233
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了栈和队列OJ题合集(包含循环队列的两种实现)相关的知识，希望对你有一定的参考价值。
目录
一:前言
对栈和队列的基本性质和实现有问题的可以看上一期
注意:本文用数据的大小来表示入栈入队的先后。
二:有效的括号(括号匹配)
题目链接:https://leetcode.cn/problems/valid-parentheses/
题目要求:
基础思路:
(1)这个问题实质上就是左右括号的配对。(左括号:'(' ' [ ' ' ' ; 右括号:' ) ' ' ] ' ' ')
(2)我们可以从左往右遍历这个字符串，符号为左括号时，我们可以把这个元素压入栈中。如果遇到的元素是右括号，我们就拿出栈中的元素进行匹配，匹配成功就继续遍历，不成功就直接返回false，遍历到字符串结束就停止循环。
(3)考虑几种特殊情况
①比如"( ( )",这个字符串很明显左右括号没法完全匹配，但它可以进行一次匹配后到空，这个时候我们应该返回false。为了解决这个情况，我们可以设置一个bool类型的变量，调用对栈判空的接口，返回这个变量。
②比如"( ) )"或者") ) )",这两个字符串的问题是到应该匹配的时候栈为空了，很明显这两个字符串不符号要求，所以我们应该在匹配之前进行栈判空，为空直接返回false。
图解：
代码(PS:可以把上一次写的栈复制过来)：
//重定义数据类型，方便更改 typedef char 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); //取栈顶的数据 STDataType StackTop(ST* ps); //取栈中的有效数据个数 int StackSize(ST* ps); //判断栈是否为空 bool StackEmpty(ST* ps); //初始化 void StackInit(ST* ps) //断言，不能传空指针进来 assert(ps ); //一开始指向NULL ps->a = NULL; //把栈顶和容量都置为空 ps->top = ps->capacity = 0; //销毁 void StackDestroy(ST* ps) //断言，不能传空指针进来 assert(ps ); //栈顶和容量置为空 ps->top = ps->capacity = 0; //释放空间 free(ps->a); ps->a = NULL; //入栈 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) printf("realloc error\\n"); exit(-1); //更新 ps->capacity = newcapacity; ps->a = tmp; //存储数据 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]; //取栈中的有效数据个数 int StackSize(ST* ps) //断言，不能传空指针进来 assert(ps); //直接返回top return ps->top; //判断栈是否为空 bool StackEmpty(ST* ps) //断言，不能传空指针进来 assert(ps); //依据top来判断 /*if (ps->top == 0) return true; return false;*/ //更简洁的写法,一个判断语句的值要么为true,要么false return ps->top == 0; bool isValid(char * s) ST s1; //初始化 StackInit(&s1); while(*s) //如果为左括号，入栈 if(*s=='('||*s=='['||*s=='') StackPush(&s1,*s); //如果为右括号，出栈看是否相同 else //如果栈为空，说明没有左括号对应，返回false if(StackEmpty(&s1)) StackDestroy(&s1); return false; //先记录然后出栈 STDataType top=StackTop(&s1); StackPop(&s1); //判断是否可以对应 if(*s==')'&&top!='(' ||*s==''&&top!='' ||*s==']'&&top!='[') //注意销毁栈 StackDestroy(&s1); return false; //后移一位 s++; //判断栈是否为空 bool ret=StackEmpty(&s1); //注意销毁栈 StackDestroy(&s1); return ret;
三:用队列实现栈
题目链接:https://leetcode.cn/problems/implement-stack-using-queues/
题目要求：
基础思路：
(1)我们都知道栈是先进后出而队列是先进先出，这也就代表我们要用队列实现栈的一些操作，基本都是需要反向来的。
(2)为了方便我们出数据和查找数据，我们保持一个队列为空，将栈的数据放在非空队列中。
PS:可以把上一次写的队列复制过来。
栈的结构体和初始化，比较简单，不做过多解析
代码：
void myStackPush( )函数（存储数据）
①比较简单，只需要向非空队列中存储就行。
myStackPop( )函数（删除数据）
①我们要出栈，实际就是出队列中的队尾元素。
我们需要找到队尾元素，这个操作通过不断出队列，一直到队列只有一个数据(不把队列是否为空设置为循环条件是因为我们要返回栈顶数据)就能实现。
②但我们不想让前面的元素也出栈，就需要将这些元素在出队之前先入到另一个空队列中，这样就可以保证数据不丢失了。
图解:
代码：
myStackTop( )函数（返回栈顶数据）
①也比较简单，我们只需要将非空队列的尾部队列元素返回就行。
代码:
myStackEmpty( )函数（判断是否为空）
①前面我们说只用一个队列存储栈的数据，所以如果两个队列都为空那就代表栈为空。
代码:
myStackFree( )函数（销毁）
①需要注意的点就是不要直接释放栈结构体，要先把两个队列释放了。
图解:
代码：
完整代码:
//重定义，方便更改存储类型 typedef int QDataType; //结点的结构体 typedef struct QueueNode struct QueueNode* next; QDataType data; QNode; //队列的结构体（头用来开辟链接，尾用来查找） typedef struct Queue //头 QNode* head; //尾 QNode* tail; Queue; //队列的初始化 void QueueInit(Queue* pq); //入队列（队列只能从后入） void QueuePush(Queue* pq, QDataType x); //队列的销毁 void QueueDestroy(Queue* pq); //出队列（删除） void QueuePop(Queue* pq); //判断队列是否为空 bool QueueEmpty(Queue* pq); //查找队列的头数据 QDataType QueueFront(Queue* pq); //查找队列的尾数据 QDataType QueueBack(Queue* pq); //查找队列的结点个数 int QueueSize(Queue* pq); //初始化 void QueueInit(Queue* pq) //断言，不能传空的结构体指针 assert(pq); //初始化，把头和尾都指向空 pq->head = pq->tail = NULL; //入队列 void QueuePush(Queue* pq,QDataType x) //断言，不能传空的结构体指针 assert(pq); //申请新结点 QNode* newnode = (QNode*)malloc(sizeof(QNode)); newnode->data = x; newnode->next = NULL; //如果队列为空，单独处理 if (pq->head == NULL) pq->head = pq->tail = newnode; else //原尾指向新结点（链接） pq->tail->next = newnode; //更新尾 pq->tail = newnode; //队列销毁 void QueueDestroy(Queue* pq) //断言，不能传空的结构体指针 assert(pq); //先保存下一个，再释放 QNode* cur = pq->head; while (cur) //记录 QNode* next = cur->next; //释放 free(cur); //迭代 cur = next; //头尾都置空 pq->head = pq->tail = NULL; //出队列（删除） void QueuePop(Queue* pq) //断言，不能传空的结构体指针 assert(pq); //断言，队列为空不能删除 assert(!QueueEmpty(pq)); //保存原头的下一个结点位置 QNode* newhead = pq->head->next; //释放 free(pq->head); //迭代 pq->head = newhead; //如果删除结束了，要把tail指向空（避免野指针） if (pq->head == NULL) pq->tail = NULL; //判断队列是否为空 bool QueueEmpty(Queue* pq) //断言，不能传空的结构体指针 assert(pq); /*if (pq->head == NULL) return true; else return false;*/ //依据判断语句的指直接返回 return pq->head == 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 size = 0; //遍历链表 QNode* cur = pq->head; while (cur) size++; cur = cur->next; return size; typedef struct Queue q1; Queue q2; MyStack; MyStack* myStackCreate() //自己申请一块空间 MyStack* st=(MyStack*)malloc(sizeof(MyStack)); //初始化队列 QueueInit(&st->q1); QueueInit(&st->q2); //返回结构体指针 return st; void myStackPush(MyStack* obj, int x) //如果q1不为空，向q1存储数据，不然向q2存储数据 if(!QueueEmpty(&obj->q1)) QueuePush(&obj->q1,x); else QueuePush(&obj->q2,x); int myStackPop(MyStack* obj) //假设q1为空，q2不为空 Queue* emptyQ=&obj->q1; Queue* nonemptyQ=&obj->q2; //如果q1不为空，更改 if(!QueueEmpty(&obj->q1)) emptyQ=&obj->q2; nonemptyQ=&obj->q1; //一直出非空队列的数据并存储到原空队列中，一直到剩余一个数据 while(QueueSize(nonemptyQ)>1) QueuePush(emptyQ,QueueFront(nonemptyQ)); QueuePop(nonemptyQ); //返回栈顶数据 int top=QueueFront(nonemptyQ); //出栈 QueuePop(nonemptyQ); return top; int myStackTop(MyStack* obj) //如果q1不为空，返回q1的尾数据，否则返回q2的尾数据 if(!QueueEmpty(&obj->q1)) return QueueBack(&obj->q1); else return QueueBack(&obj->q2); bool myStackEmpty(MyStack* obj) //两个队列同时空就是空,判断语句的值就是true或false return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2); void myStackFree(MyStack* obj) //先释放内部的队列，最后释放栈结构体空间 QueueDestroy(&obj->q1); QueueDestroy(&obj->q2); free(obj);
四:用栈实现队列
题目链接:https://leetcode.cn/problems/implement-queue-using-stacks/
题目要求:
基础思路：
①与前面不同，将一个栈通过取栈顶数据到另一个栈是可以把原栈的数据顺序颠倒的。
②我们可以仿照前面的思路，不过因为移动一次数据的顺序就会颠倒，所以不需要频繁的移动数据，一个栈专门用来存储数据(简称入栈)，一个栈专门用来出数据(简称出栈)。
③如果出栈的数据为空，我们需要将入栈的元素补充到出栈中。
图解：
PS:可以把上一次写的栈复制过来。
队列结构体和初始化比较简单，不赘述。
代码：
myQueuePush( )函数（存储数据）
①很简单，往入栈入数据就行。
代码：
myQueuePop( )函数（删除数据）
①如果出栈为空，将入栈的数据移到出栈。
②先保存要出的数据，然后直接把出栈的栈顶出掉就行。
代码：
myQueuePeek( )函数（返回队头数据）
①一般来说出栈的栈顶就是队头，但如果出栈为空，我们要将入栈的数据移到出栈。
②直接返回出栈的栈顶。
代码:
myQueueEmpty( )函数 （判断是否为空）
①如果出栈入栈都为空，队列就为空。
代码：
myQueueFree( )函数（销毁）
①要注意的点和前面类似，不能直接释放队列结构体，要先释放两个栈，然后释放队列结构体。
代码：
完整代码：
//重定义数据类型，方便更改 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); //取栈顶的数据 STDataType StackTop(ST* ps); //取栈中的有效数据个数 int StackSize(ST* ps); //判断栈是否为空 bool StackEmpty(ST* ps); //初始化 void StackInit(ST* ps) //断言，不能传空指针进来 assert(ps ); //一开始指向NULL ps->a = NULL; //把栈顶和容量都置为空 ps->top = ps->capacity = 0; //销毁 void StackDestroy(ST* ps) //断言，不能传空指针进来 assert(ps ); //栈顶和容量置为空 ps->top = ps->capacity = 0; //释放空间 free(ps->a); ps->a = NULL; //入栈 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) printf("realloc error\\n"); exit(-1); //更新 ps->capacity = newcapacity; ps->a = tmp; //存储数据 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]; //取栈中的有效数据个数 int StackSize(ST* ps) //断言，不能传空指针进来 assert(ps); //直接返回top return ps->top; //判断栈是否为空 bool StackEmpty(ST* ps) //断言，不能传空指针进来 assert(ps); //依据top来判断 /*if (ps->top == 0) return true; return false;*/ //更简洁的写法,一个判断语句的值要么为true,要么false return ps->top == 0; typedef struct //一个入，一个出 ST PushSt;//出栈 ST PopSt;//入栈 MyQueue; MyQueue* myQueueCreate() MyQueue* newQueue=(MyQueue*)malloc(sizeof(MyQueue)); //初始化栈 StackInit(&newQueue->PushSt); StackInit(&newQueue->PopSt); return newQueue; void myQueuePush(MyQueue* obj, int x) //入 StackPush(&obj->PushSt,x); int myQueuePop(MyQueue* obj) //如果要出的那个栈为空，将入栈的元素全部移到出栈中 if(StackEmpty(&obj->PopSt)) while(!StackEmpty(&obj->PushSt)) StackPush(&obj->PopSt,StackTop(&obj->PushSt)); StackPop(&obj->PushSt); //出队列 int top=StackTop(&obj->PopSt); StackPop(&obj->PopSt); return top; int myQueuePeek(MyQueue* obj) //如果要出的那个栈为空，将入元素的栈的元素全部移到出栈中 if(StackEmpty(&obj->PopSt)) while(!StackEmpty(&obj->PushSt)) StackPush(&obj->PopSt,StackTop(&obj->PushSt)); StackPop(&obj->PushSt); //返回出栈的top return StackTop(&obj->PopSt); bool myQueueEmpty(MyQueue* obj) //两个栈都为空，队列为空,判断语句的值为true或false return StackEmpty(&obj->PopSt)&&StackEmpty(&obj->PushSt); void myQueueFree(MyQueue* obj) //先释放栈，再释放队列结构体 StackDestroy(&obj->PushSt); StackDestroy(&obj->PopSt); free(obj);
五:设计循环队列
题目链接:https://leetcode.cn/problems/design-circular-queue/
题目要求：
思路(解释)：
(1)循环队列顾名思义就是一个循环的结构，链式结构通过头尾相连来实现循环，
数组结构通过对下标的控制来实现循环，我们看图：
(2)判断队列为空或者满 ，如果我们需要存储多少个数据就开辟多少空间的话，我们可以将头尾相同作为空的条件，但是无法判断满的条件。
我们可以多开辟一个空间，将(tail+1)%(存储元素个数+1)==front或者tail->next==front作为判满的条件。
图解：
【1】数组结构
(1)队列结构体定义和初始化
(2)myCircularQueueIsFull( )函数 （判断是否为满）
思路：无非是有一种tail为k，front为0的情况要特殊处理。
其它的全都为tail+1=front。
代码：
(3)myCircularQueueIsEmpty( )函数 （判断是否为空）
思路：比较简单，tail与front相等就为空。
代码：
(4)myCircularQueueEnQueue( )函数 （存储数据）
思路：先判断是否为满，满不插入。
不满就插入然后tail+1,如果加1后tail为k，就回到下标0位置。
代码：
(5)myCircularQueueDeQueue( )函数 （删除数据）
思路：先判断是否为空，空不删除。
否则就直接front+1，如果front为k，就回到下标0位置。
代码：
(6)myCircularQueueFront( )函数（返回队头数据）和myCircularQueueRear( )函数（返回队尾数据）
思路：两个函数都比较简单，都要先判断是否为空。
myCircularQueueFront( )直接返回下标front的数据就行。
myCircularQueueRear( )就需要处理一种tail为0的情况，其它情况返回下标为k-1处的数据。
代码：
(7)myCircularQueueFree( )函数
最后不要忘记释放空间
代码：
完整代码：
typedef struct int* a;//存储数据 int front;//头 int tail;//尾 int k;//记录 MyCircularQueue; //后面有的接口要用到这两个函数，注意进行函数声明 bool myCircularQueueIsEmpty(MyCircularQueue* obj); bool myCircularQueueIsFull(MyCircularQueue* obj); MyCircularQueue* myCircularQueueCreate(int k) //给结构体开空间 MyCircularQueue* q=(MyCircularQueue*)malloc(sizeof(MyCircularQueue)); //给数组开空间 q->k=k; q->a=(int *)malloc(sizeof(int)*(k+1)); q->front=q->tail=0; return q; bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) //如果满，返回false if(myCircularQueueIsFull(obj)) return false; //存储数据，后移一位 obj->a[obj->tail]=value; obj->tail++; //如果超出范围，回到下标0位置 // if(obj->tail==obj->k+1) // obj->tail=0; obj->tail%=(obj->k+1); return true; bool myCircularQueueDeQueue(MyCircularQueue* obj) //如果空，返回false if(myCircularQueueIsEmpty(obj)) return false; obj->front++; //如果超出范围，回到下标0位置 // if(obj->front==obj->k+1) // obj->front=0; obj->front%=(obj->k+1); return true; int myCircularQueueFront(MyCircularQueue* obj) //如果空，返回-1 if(myCircularQueueIsEmpty(obj)) return -1; return obj->a[obj->front]; int myCircularQueueRear(MyCircularQueue* obj) //如果空，返回-1 if(myCircularQueueIsEmpty(obj)) return -1; //也可以用取余的方法找到下标 // int i=(obj->tail+obj->k)%(obj->k+1); // return obj->a[i]; //如果tail为0，下标k位置为队尾，否则下标tail-1位置为队尾 if(obj->tail==0) return obj->a[obj->k]; else return obj->a[obj->tail-1]; bool myCircularQueueIsEmpty(MyCircularQueue* obj) return obj->front==obj->tail; bool myCircularQueueIsFull(MyCircularQueue* obj) //另外一种 // if(obj->tail+1==obj->front||(obj->tail==obj->k&&obj->front==0)) // return true; // else // return false; //比较简洁 return (obj->tail+1)%(obj->k+1)==obj->front; void myCircularQueueFree(MyCircularQueue* obj) //先释放数组 free(obj->a); //最后释放结构体 free(obj);【2】链式结构
链式结构的实现只有两个接口需要重点讲一下，其它接口思路和数组结构类似。
(1)结构体和初始化
初始化思路：
①我们需要多申请一个空间，并且每一次申请完都要链接起来。
②最后要形成循环。
图解：
代码：
(2)队列的释放
思路：
①先记录头指针的位置，然后让头指针指向下一个结点 。
②利用头指针来就行释放，结束条件为头指针回到原来位置。
③记得释放掉这个头结点和队列结构体。
图解：
代码：
完整代码：
//结点的结构体 typedef struct QueueNode struct QueueNode* next; int data; QNode; typedef struct QNode* head; QNode* tail; MyCircularQueue; bool myCircularQueueIsEmpty(MyCircularQueue* obj); bool myCircularQueueIsFull(MyCircularQueue* obj); MyCircularQueue* myCircularQueueCreate(int k) //申请结构体的空间 MyCircularQueue* q = (MyCircularQueue*)malloc(sizeof(MyCircularQueue)); //初始化 q->tail = q->head = (QNode*)malloc(sizeof(QNode)); //申请空间并链接 while (k--) QNode* newnode = (QNode*)malloc(sizeof(QNode)); newnode->next = NULL; q->tail->next = newnode; q->tail = newnode; //最后形成循环 q->tail->next = q->head; //把尾指针回归原点 q->tail = q->head; return q; bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) //如果已经满了，不能入数据 if (myCircularQueueIsFull(obj)) return false; //存储数据 obj->tail->data = value; obj->tail = obj->tail->next; return true; bool myCircularQueueDeQueue(MyCircularQueue* obj) //如果为空，不能删除数据 if (myCircularQueueIsEmpty(obj)) return false; obj->head = obj->head->next; return true; int myCircularQueueFront(MyCircularQueue* obj) //如果为空，不能查找数据 if (myCircularQueueIsEmpty(obj)) return -1; return obj->head->data; int myCircularQueueRear(MyCircularQueue* obj) //如果为空，不能查找数据 if (myCircularQueueIsEmpty(obj)) return -1; //循环，一直到找到tail的前一个结点为止 QNode* cur = obj->head; while (cur->next!=obj->tail) cur = cur->next; return cur->data; bool myCircularQueueIsEmpty(MyCircularQueue* obj) //头尾相同为空 return obj->head == obj->tail; bool myCircularQueueIsFull(MyCircularQueue* obj) //尾的下一个就是头，为满 return obj->tail->next == obj->head; void myCircularQueueFree(MyCircularQueue* obj) //先记录头指针，利用头指针释放空间 QNode* endpoint = obj->head; obj->head = obj->head->next; while (endpoint != obj->head) QNode* freeQ = obj->head; obj->head = obj->head->next; free(freeQ); //最后不要忘记释放原来的头结点 free(endpoint); //释放结构体 free(obj);
数据结构之队列的基本操作以及栈和队列的OJ题画图详解
队列
文章目录
队列的概念
只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出
FIFO(First In First Out) 的特性
入队列：
进行插入操作的一端称为队尾
出队列：
进行删除操作的一端称为队头先进先出
典型应用
- 队列实际中要保证公平排队的地方都可以用它
比如在银行我们以前是排队，比如有三个窗口依次排队，但是有的窗口快，有的窗口慢，就有点不公平，后面出现了叫号机，而这个叫号机的系统就是队列的应用，满足了先到先办理业务，很公平，也是队列的特性先进先出的体现。
- 广度优先遍历
数据结构中图的广度优先遍历也是用队列实现的。
队列的实现
队列的实现既可以用数组的结构实现，也可以用链表的结构实现，那么哪一种更好呢？
经过上面的分析，发现链表的结构实现对应更优
那么我们就用链表的结构来实现队列：
首先我们创建文件
文件的创建
Queue.h对相关头文件的包含，以及实现队列的结构和函数的声明
Queue.c对实现队列操作的函数进行定义
test.c文件进行队列相关函数和单链表功能的测试
队列结构的定义
创建好文件后，我们首先来看队列结构的定义
typedef int QDataType;
//队列的链式结构结点的结构
typedef struct QueueNode
{
QDataType data;
struct QueueNode* next;
}QueueNode;
结点的结构
我们知道我们队列的插入数据在队尾插入，而插入需要找尾，我们不妨设一个指向尾的指针，然后将头指针和它封装成一个结构体：
typedef struct Queue
{
QueueNode* phead;
QueueNode* ptail;
}Queue;
接下来我们来看队列的下面操作：
//队列初始化
void QueueInit(Queue *pq);
//队列的销毁
void QueueDestory(Queue *pq);
//队列的插入
void QueuePush(Queue *pq,QDataType x);//队尾
//队列的删除
void QueuePop(Queue *pq);//队头
//队列的大小
int QueueSize(Queue *pq);
//取队头元素
QDataType QueueFront(Queue *pq);
//取队尾元素
QDataType QueueBack(Queue *pq);
//判队列是否为空
bool QueueEmpty(Queue *pq);
首先是队列的初始化：
队列初始化
//队列的初始化
void QueueInit(Queue* pq)
{
assert(pq);
pq->phead = pq->ptail = NULL;
}
我们调试发现我们已经将phead和ptail置空
队列的销毁
//队列的销毁
void QueueDestory(Queue* pq)
{
assert(pq);
QueueNode* cur = pq->phead;
while (cur)
{
QueueNode* next = cur->next;
free(cur);
cur = next;
}
pq->phead = pq->ptail = NULL;
}
我们首先断言一下pq不能为空，然后将phead赋给cur，开始迭代free，free前将cur的next保存下来，最后再将phead和ptail都置为空
队列的打印
//队列的打印
void QueuePrint(Queue* pq)
{
assert(pq);
QueueNode* cur = pq->phead;
while (cur)
{
printf("%d->", cur->data);
cur = cur->next;
}
printf("NULL\\n");
}
我们也是将phead赋给cur，然后利用cur进行迭代打印数据
队列的插入
//队列的插入
void QueuePush(Queue* pq, QDataType x)//队尾
{
assert(pq);
QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
if (newnode == NULL)
{
perror("malloc");
return;
}
if (pq->phead == NULL)//没有结点时
{
pq->phead = pq->ptail = newnode;
}
else//有结点时
{
pq->ptail->next = newnode;
pq->ptail = newnode;
}
}
因为我们插入元素只有这里能用到，所以我们就不将它写成和我们之前写的单链表那样单独写一个函数创建结点，我们开辟好一个结点，当队列没有结点时，我们将newnode赋给phead和ptail，有结点时我们直接将newnode赋给ptail的next，将newnode更新成尾
可以看到我们插入成功了
队列的删除
//队列的删除
void QueuePop(Queue* pq)//队头
{
assert(pq);
assert(!QueueEmpty(pq));//队列不为空
if (pq->phead->next == NULL)//只有一个结点时
{
free(pq->phead);
pq->phead = pq->ptail = NULL;
}
QueueNode* next = pq->phead->next;
free(pq->phead);
pq->phead = next;
//当队列中只剩下一个结点时，删除只是将phead置NULL了,
//但是ptail并没有置空，此时它是野指针，故我们前面需考虑只剩一个结点时的情况
}
当队列中只剩下一个结点时，删除只是将phead置NULL了,但是ptail并没有置空，此时它是野指针，故我们前面需考虑只剩一个结点时的情况。当只有一个结点时，我们free phead，然后将phead和ptail都置为空
上图是测试结果
队列的大小
//队列的大小
int QueueSize(Queue* pq)
{
assert(pq);
int size = 0;
QueueNode* cur = pq->phead;
while (cur)
{
size++;
cur = cur->next;
}
return size;
}
取队头元素
//取队头元素
QDataType QueueFront(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->phead->data;
}
断言队列不能为空，phead就是队头，返回它的数据。
取队尾元素
//取队尾元素
QDataType QueueBack(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->ptail->data;
}
ptail是尾，返回它的数据
判断是否是空队列
//判断是否是空队列
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->phead == NULL && pq->ptail == NULL;
}
phead和ptail为空时，队列为空
链表，栈，队列的操作实现时，关于函数传参传什么的问题：
-
传二级指针(头指针可以在函数里面解引用改变)
-
返回值(接收返回值改变)
-
带哨兵位的头结点(不会改变头指针)
-
结构体包一起(用结构体指针改变)
下面是队列实现的源代码：
源代码
Queen.h
typedef int QDataType;
typedef struct QueueNode
{
struct QueueNode* next;
QDataType data;
}QueueNode;
typedef struct Queue
{
QueueNode* phead;
QueueNode* ptail;
}Queue;
void QueueInit(Queue *pq);
void QueueDestory(Queue *pq);
void QueuePush(Queue *pq,QDataType x);//队尾
void QueuePop(Queue *pq);//队头
int QueueSize(Queue *pq);
QDataType QueueFront(Queue *pq);
QDataType QueueBack(Queue *pq);
bool QueueEmpty(Queue *pq);
Queen.c
void QueueInit(Queue *pq)
{
assert(pq);
pq->phead = pq->ptail = NULL;
}
void QueueDestory(Queue *pq)
{
assert(pq);
QueueNode* cur = pq->phead;
while(cur)
{
QueueNode* next=cur->next;
free(cur);
cur=next;
}
pq->phead=pq->ptail=NULL;
}
void QueuePush(Queue *pq,QDataType x)//队尾
{
assert(pq);
QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
if(newnode==NULL)
{
perror("malloc");
return;
}
newnode->data=x;
newnode->next=NULL;
if(pq->ptail==NULL)
{
pq->phead=pq->ptail=newnode;
}
else
{
pq->ptail->next = newnode;
pq->ptail = newnode;
}
}
bool QueueEmpty(Queue *pq)
{
assert(pq);
return pq->ptail==NULL && pq->phead==NULL;
}
void QueuePop(Queue *pq)//队头
{
assert(pq);
//删数据
assert(!QueueEmpty(pq));
if(pq->phead->next==NULL)
{
free(pq->phead);
pq->phead=pq->ptail=NULL;
}
else
{
QueueNode* next=pq->phead->next;
free(pq->phead);
pq->phead=next;
//如果被删空了，ptail指向的结点已经free了 但是它没有置空
//ptail是个野指针
}
}
int QueueSize(Queue *pq)
{
assert(pq);
//如果频繁调用这个接口函数，将size也放进Queue结构体中
QueueNode* cur = pq->phead;
int size=0;
while(cur)
{
size++;
cur=cur->next;
}
return size;
}
QDataType QueueFront(Queue *pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->phead->data;
}
QDataType QueueBack(Queue *pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->ptail->data;
}
test.c
int main()
{
Quenu q;
QueueInit(&q);
QueuePush(&q,1);
QueuePush(&q,2);
QueuePush(&q,3);
QueuePush(&q,4);
return 0;
}
栈和队列的OJ题
用队列实现栈
题目描述：
请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。
实现 MyStack 类：
void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。
题目来源：用队列实现栈
思路：
我们在用两个队列实现栈，队列是先进先出，而栈是先进后出，我们现在进去的顺序是1、2、3、4，而要实现栈的功能，我们出栈则应该要4先出，那么怎么样才能让4出呢？我们接着往下看思路
那么我们入数据怎么入呢？
入数据在不为空的队列入，我们想一想栈是后进先出，那么下次出数据操作，我们按照上面的操作，不就是出的5嘛，所以我们入数据在不为空的队列
我们来总结一下思路：
- 一个队列有数据，一个队列没数据
- 入数据在不为空的那个队列入
- 出数据，把不为空的队列的前n-1个导入到空队列中，pop掉最后剩下的一个数据
代码如下：
//栈的结构--两个队列
typedef struct {
Queue q1;
Queue q2;
} MyStack;
/** Initialize your data structure here. */
//栈的创建
MyStack* myStackCreate() {
MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
if(pst==NULL)
{
perror("malloc MyStack");
return NULL;
}
QueueInit(&pst->q1);
QueueInit(&pst->q2);
return pst;
}
/** Push element x onto stack. */
//进栈
void myStackPush(MyStack* obj, int x) {
assert(obj);
/*Queue* emptyQ=&obj->q1;//假设q1为空
Queue* nonemptyQ=&obj->q2;//假设q2不为空
if(!QueueEmpty(&obj->q1))//如果q1不为空则
{
emptyQ=&obj->q2;
nonemptyQ=&obj->q1;
}
QueuePush(nonemptyQ,x);//在不为空的队列里入数据*/
if(!QueueEmpty(&obj->q1))
{
QueuePush(&obj->q1,x);
}
else
{
QueuePush(&obj->q2,x);
}
}
bool myStackEmpty(MyStack* obj) {
assert(obj);
return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}
/** Removes the element on top of the stack and returns that element. */
//出栈
int myStackPop(MyStack* obj) {
assert(obj);
Queue* emptyQ=&obj->q1;//假设q1为空
Queue* nonemptyQ=&obj->q2;//假设q2不为空
if(!QueueEmpty(&obj->q1))//如果q1不为空则
{
emptyQ=&obj->q2;
nonemptyQ=&obj->q1;
}
while(QueueSize(nonemptyQ)>1)
{
QueuePush(emptyQ,QueueFront(nonemptyQ));//将队列的队头入到空队列中
QueuePop(nonemptyQ);//pop数据
}
int front = QueueFront(nonemptyQ);
QueuePop(nonemptyQ);
return front;
}
/** Get the top element. */
int myStackTop(MyStack* obj) {
assert(obj);
if(!QueueEmpty(&obj->q1))
{
return QueueBack(&obj->q1);
}
else
{
return QueueBack(&obj->q2);
}
}
/** Returns whether the stack is empty. */
void myStackFree(MyStack* obj) {
assert(obj);
QueueDestory(&obj->q1);
QueueDestory(&obj->q2);
free(obj);
}
设计循环队列
题目描述：
设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
你的实现应该支持如下操作：
MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。
题目来源：设计循环队列
在看完题目之后，我们可以知道它是这样的结构：
我们这样设计：front和rear分别指向头和尾的下一个元素，循环队列的结构既可以用链表结构也可以用顺序表结构，链表结构最后一个元素的next指向头，顺序表等到rear到达边界时，让他回到下标为0的地方，这样我们的顺序表和链表达到了循环的目的。
那么怎么插入数据和删除数据呢？
插入数据：
可以看到插入数据将rear后移，当front等于rear时，队列为满
删除数据：
删除数据我们直接让front移动，数据不用管，front和rear直接的数据才是有效数据，可以看到删除数据将front后移，当front等于rear时，队列为空
那么我们来看这样一个问题：
那么这里我们考虑到将空间加一个单位：
多增加一个单位空间，如上图顺序表中，队列的长度为7，但是我们实际最多只存储6个数据，当rear的下一个存储空间等于front时，我们就说队列是满的
我们假设k是实际存储的数据个数，则只要(rear+1)%(k+1)==front时，队列是满的，那么front==rear时，队列是空的。
下面我们开始写代码，我们这道题用顺序表结构来写，这里我建议大家用顺序表写，因为顺序表缓存利用率高，而且不用一直开辟节点。
首先我们创建循环队列的结构体：
typedef struct{
int *a;//指向动态开辟的内存的指针,这块内存用来存储数据
int front;//队头的下标
int rear;//队尾的下一个元素的下标
int k;//数据的个数
}MyCircularQueue;
我们创建了指向动态开辟的内存的指针a，队头的下标，队尾的下一个元素的下标，数据的个数k
接下来我们来看循环队列的创建初始化函数：
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* q = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
q->a = (int*)malloc((<以上是关于栈和队列OJ题合集(包含循环队列的两种实现)的主要内容，如果未能解决你的问题，请参考以下文章
数据结构C语言篇《三》栈和队列概念，模拟函数实现，以及相关OJ面试题