【数据结构之队列】
数据结构学习笔记---006
- 数据结构之队列
-
- 1、队列的概念和结构
-
- 1.1、如何实现队列？
- 2、队列的实现
-
- 2.1、队列的Queue.h
- 2.2、队列的Queue.c
-
- 2.2.1、队列的初始化
- 2.2.2、队列销毁
- 2.2.3、队列入队、出队操作
- 2.2.4、队列取队头、队尾操作
- 2.2.5、队列的判空
- 2.2.5、取队内元素大小
- 2.3、队列的main.c
- 3、队列巩固练习
-
- 3.1、练习题1：用队列实现栈
- 3.2、练习题2：用栈实现队列
- 3.3、练习题3：设计循环队列
数据结构之队列
前言：
前篇学习了 数据结构的栈，那么这篇继续学习队列的基础内容。
/知识点汇总/
1、队列的概念和结构
队列：只允许在一端进行数据操作，在另一端进行删除数据操作的特殊线性表
队列具有先进先出(FIFO:First In First Out)的特点.
入队列操作：进行插入操作的一端称为队尾。
出队列操作：进行删除操作的一端称为队头。
与栈不同，队列的出队列顺序与出队列顺序是唯一的。
比如入队顺序：1，2，3，4
则出队顺序：1，2，3，4
1.1、如何实现队列？
双向链表、数组、单链表？
排除数组，大量挪动数据
其次，能用单链表解决就暂时不用双链表。所以采用类似于单链表的形式实现。另外，由于队列的特性，一端进队列，另一端出队列，所以额外定义一个结构体类型更加便于操作。
队列的存储结构
typedef int QDataType;
//定义队列结构体成员和变量
typedef struct QueueNode
{
QDataType val;
struct QDataNode* next;
}QNode;
//由于队列的使用，存在多个值，采用结构体的指针，就不用二级指针了。
typedef struct Queue
{
QNode* phead;
QNode* ptail;
int size; //以空间换时间，解决求队内元素个数的时间复杂度问题
}Queue;
2、队列的实现
2.1、队列的Queue.h
//队列初始化
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);
2.2、队列的Queue.c
队列的操作算是比较简单，理解性掌握即可。只需要注意一下，操作空队列和一个元素的情况的处理即可。
2.2.1、队列的初始化
//队列初始化
void QueueInit(Queue* pq)
{
assert(pq);
pq->phead = pq->ptail = NULL;
pq->size = 0;
}
2.2.2、队列销毁
//队列销毁
void QueueDestory(Queue* pq)
{
assert(pq);
QNode* cur = pq->phead;
while (cur)
{
QNode* next =cur->next;
free(cur);
cur = next;
}
pq->phead = pq->ptail = NULL;
pq->size = 0;
}
2.2.3、队列入队、出队操作
//队列入队
void QueuePush(Queue* pq, QDataType x)
{
assert(pq);
QNode* newnode = (QNode*)malloc(sizeof(QNode));
if (newnode == NULL)
{
perror("malloc fail");
return;
}
newnode->next = NULL;
newnode->val = x;
if (pq->ptail == NULL)
{
pq->ptail = pq->phead = newnode;
}
else
{
pq->ptail->next = newnode;
pq->ptail = newnode;
}
pq->size++;
}
//队列出队
void QueuePop(Queue* pq)
{
assert(pq);
//判空
assert(pq->phead);
//一个节点的情况
QNode* del = pq->phead;
pq->phead = pq->phead->next;
free(del);
del = NULL;
if (pq->phead == NULL)
{
pq->ptail = NULL;
}
pq->size--;
}
2.2.4、队列取队头、队尾操作
//取队头
QDataType QueueFront(Queue* pq)
{
assert(pq);
//判空
assert(pq->phead);
return pq->phead->val;
}
//取队尾
QDataType QueueBack(Queue* pq)
{
assert(pq);
//判空
assert(pq->phead);
return pq->ptail->val;
}
2.2.5、队列的判空
//判空
bool QueueEmpty(Queue* pq)
{
assert(pq);
//判空
return pq->phead == NULL;
}
2.2.5、取队内元素大小
//取队内元素大小
int QueueSize(Queue* pq)
{
assert(pq);
//判空
//assert(pq->phead);
return pq->size;
}
2.3、队列的main.c
#include "Queue.h"
//测试1：
void TestQ1()
{
Queue q;
QueueInit(&q);//初始化
QueuePush(&q, 1);//入队
QueuePush(&q, 2);//入队
QueuePush(&q, 3);//入队
QueuePush(&q, 4);//入队
QueuePush(&q, 5);//入队
while (!QueueEmpty(&q))
{
printf("%d ", QueueFront(&q));
QueuePop(&q);
}
QueueDestory(&q);//销毁
}
//测试2：
void TestQ2()
{
Queue q;
QueueInit(&q);//初始化
QueuePush(&q, 1);//入队
QueuePush(&q, 2);//入队
QueuePush(&q, 3);//入队
printf("%d ", QueueFront(&q));
QueuePop(&q);
QueuePush(&q, 4);//入队
printf("%d ", QueueFront(&q));
QueuePop(&q);
QueuePush(&q, 5);//入队
while (!QueueEmpty(&q))
{
printf("%d ", QueueFront(&q));
QueuePop(&q);
}
QueueDestory(&q);//销毁
}
int main()
{
//TestQ1();
TestQ2();
return 0;
}
小结：
队列的元素入队出队顺序是固定的，属于一对一的关系
3、队列巩固练习
3.1、练习题1：用队列实现栈
练习题1：用队列实现栈 – 实现两个队列实现先进后出栈的push、top、pop、empty
思路：将第一个队列出队，到第二个队列入队，然后反复颠倒，直到按栈的方式完成所有操作。
核心：一个队列存储数据，另一个队列在出队列时，倒数据。
#include "Queue.h"
typedef struct
{
Queue q1;
Queue q2;
}MyStack;
MyStack* myStackCreat()
{
MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
QueueInit(&pst->q1);//注意这里的传参 ，栈地址
QueueInit(&pst->q2);
return pst;
}
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* noemptyq = &obj->q2;
if (!QueueEmpty(&obj->q1))
{
emptyq = &obj->q2;
noemptyq = &obj->q1;
}
//将非空队列前N-1个导入空队列，最后一个就是要的栈顶元素。
while (QueueSize(noemptyq) > 1)
{
QueuePush(emptyq, QueueFront(noemptyq));
QueuePop(noemptyq);
}
//直到栈顶元素就是最后一个元素
int top = QueueFront(noemptyq);
QueuePop(noemptyq);
return top;
}
int myStackTop(MyStack* obj)
{
if (!QueueEmpty(&obj->q1))
{
return QueueBack(&obj->q1);
}
else
{
return QueueBack(&obj->q2);
}
}
bool msStackEmpty(MyStack* obj)
{
return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}
MyStack* myStackFree(MyStack* obj)
{
QueueDestory(&obj->q1);
QueueDestory(&obj->q2);
free(obj);
obj = NULL;
return NULL;
}
int main()
{
MyStack* pst = myStackCreat();
myStackPush(pst, 1);
myStackPush(pst, 2);
myStackPush(pst, 3);
myStackPush(pst, 4);
myStackPush(pst, 5);
while (!msStackEmpty(pst))
{
printf("%d ", myStackTop(pst));
myStackPop(pst);
}
myStackFree(pst);
return 0;
}
3.2、练习题2：用栈实现队列
练习题2：用栈实现队列 – 实现两个栈实现先进先出队列的push、top、pop、empty
思路：两个栈,入数据都是入左边栈，出数据都是出右边栈，然后，右边不为空，则右边先出完，左边再倒数据。总之，右边栈没数据，左边栈再到数据。
#include 3.3、练习题3：设计循环队列
练习题3：设计循环队列 – 满足队列的先进先出的原则，其次对尾与队头被连接后形成一个循环。
注意的是，循环队列满了，就不能再入队了，删除同样需要判断是否为空了。
主要考察队头队尾的关系运算。
怎么判空？
队头等于队尾为空
怎么判满？
1.增加一个size,front = back & & size=0为空，size!=0,不为空
2.对开一个位置（解决假溢出，或者说无法区分空和满的问题），始终保持一个位置空置，当k为队列长度(数据个数)，k+1为空间个数，此时(back+1)%(k+1) == front就是满
总结：front = back就是空 back的下一个 = front就是满
思路1：以开辟多一个空间的数组实现，front指向头，back指向队尾的下一个(不建议指向队尾，不好操作)，关键在于取模运算
思路2：链表实现，front==back就是空，back->next == front就是满，但是相比数组较为复杂（唯独就是队尾不好取，单链表无法回溯，要么增加一个指针，或者双向链表）
#include "Queue.h"
typedef struct
{
int* a; //数组
int front; //头
int back; //尾
int k; //队内元素个数或队列大小
}MyCircularQueue;
MyCircularQueue* myCircularQueueCreate(int k)
{
MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
//循环队列的初始化
obj->a = (int*)malloc(sizeof(int) * (k + 1));//开辟元素个数加1个空间
obj->front = 0;
obj->back = 0;
obj->k = k;
return obj;
}
bool myCircularQueueIsFull(MyCircularQueue* obj);
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)
{
if (myCircularQueueIsFull(obj))
{
return false;
}
obj->a[obj->back] = value;
obj->back++;
//循环处理
obj->back %= (obj->k + 1);
//obj->k++;//队列的大小是固定的，不是size
return true;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueDeQueue(MyCircularQueue* obj)
{
if (myCircularQueueIsEmpty(obj))
{
return false;
}
++obj->front;
//循环处理
obj->front %= (obj->k + 1);
return true;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj)
{
return obj->front == obj->back;//队头等于队尾就为空，要注意的是此时的队尾是指向多开的空间地址
}
bool myCircularQueueIsFull(MyCircularQueue* obj)
{
return (obj->back + 1) % (obj->k + 1) == obj->front;//队尾的下一个==front就是满
}
int myCircluarQueueFront(MyCircularQueue* obj)//取队头
{
if (myCircularQueueIsEmpty(obj))
return -1;
return obj->a[obj->front];
}
//写法1：
//int myCircularQueueRear(MyCircularQueue* obj)//取队尾
//{
// //return obj->a[obj->back - 1];//直接取出这种属于，情况没有考虑到位，会涉及到越界的问题
// //两种处理方法：单独判断一下即可
// if (obj->back == 0)
// return obj->a[obj->k];//back被循环到头的位置，back==0,那么取队尾就是返回的k
// else
// return obj->a[obj->back - 1];//否则，其它情况就是满足返回back-1的位置
//}
//写法二:
int myCircularQueueRear(MyCircularQueue* obj)//取队尾
{
if (myCircularQueueIsEmpty(obj))
return -1;
return obj->a[(obj->back - 1 + obj->k + 1) % (obj->k + 1)];
//back == 0 (0-1+4+1)%(4+1) = 4 处理back == 0 准备的 处理back>0准备的
//满足上述条件，简化得出：
//return obj->a[(obj->back + obj->k) % (obj->k + 1)];
}
//扩展：
//如何计算循环队列的数据个数：正常情况下，back-front
//满足特殊情况，考虑循环情况，back-front为负数，那么就是：(back+(k+1)-front)%(k+1)
void myCirCularQueueFree(MyCircularQueue* obj)
{
free(obj->a);
obj->a = NULL;
free(obj);
obj = NULL;
}
int main()
{
MyCircularQueue* pst = myCircularQueueCreate(5);
myCircularQueueEnQueue(pst, 1);
myCircularQueueEnQueue(pst, 2);
myCircularQueueEnQueue(pst, 3);
myCircularQueueEnQueue(pst, 4);
myCircularQueueEnQueue(pst, 5);
if (!myCircularQueueIsEmpty(pst))
{
printf("%d ", myCircluarQueueFront(pst));
printf("%d ", myCircularQueueRear(pst));
}
myCircularQueueDeQueue(pst);//头删
if (!myCircularQueueIsEmpty(pst))
{
printf("%d ", myCircluarQueueFront(pst));
printf("%d ", myCircularQueueRear(pst));
}
myCirCularQueueFree(pst);
return 0;
}