[一篇读懂]C语言十二讲：栈与队列和真题实战
- 1. 与408关联解析及本节内容介绍
- 1 与408关联解析
- 2 本节内容介绍
- 2. 栈(stack)的原理解析
- 2.1 **栈：只允许在一端进行插入或删除操作的线性表**
- 2.2 栈的基本操作
- 2.3 栈的顺序存储
- 2.4 栈的链表存储
- 3. 初始化栈 - 入栈 - 出栈实战
- 4. 队列(Queue) - 循环队列原理解析
- 4.1 **队列：只允许在一端进行插入，而在另一端进行删除的线性表**
- 4.2 队列的基本操作
- 4.3 循环队列
- 循环数列元素入队
- 循环数列元素出队
- 4.4 队列的链式存储
- 存储结构
- 5. 循环队列实战
- 6. 队列实战（通过链表实现）
- 总结
- 2
- 3
- 4
- 5
- 6
1. 与408关联解析及本节内容介绍
1 与408关联解析
【2019年队列】
42.(10分)请设计一个队列，要求满足：①初始时队列为空；②入队时，允许增加队列占用空间；③出队后，出队元素所占用的空间可重复使用，即整个队列所占用的空间只增不减；④入队操作和出队操作的时间复杂度始终保持为O(1)。请回答下列问题：
(1)该队列是应选择链式存储结构，还是应选择顺序存储结构？
(2)画出队列的初始状态，并给出判断队空和队满的条件。
(3)画出第一个元素入队后的队列状态。
(4)给出入队操作和出队操作的基本过程。
栈 - 一般为选择题，大题较少；
队列 - 选择题，大题均涉及。
2 本节内容介绍
本节分为六小节讲解，包含栈，队列，循环队列的原理讲解及实战
第一小节是针对栈的原理讲解
第二小节是针对初始化栈-入栈-出栈实战
第三小节是队列-循环队列原理解析
第四小节是循环队列实战
第五小节是队列的实战（通过链表的头插，头部删除实现）
第六小节是2019年42题真题讲解
2. 栈(stack)的原理解析
2.1 栈：只允许在一端进行插入或删除操作的线性表
堆栈(stack)又称为栈或堆叠；
栈的特点是：先进后出(First In Last Out)
FILO
2.2 栈的基本操作
（类似电梯）
-
元素入栈 - 从栈顶(Top)添加一个元素
-
元素出栈 - 从栈顶(Top)删除一个元素
2.3 栈的顺序存储
栈是结构体
用数组存储数据
top是栈顶
- 元素入栈&出栈代码实现
//初始化
S.top = -1;//栈为空
//入栈
S.top = S.top + 1;
S.data[S.top] = 1;
S.top = S.top + 1;
S.data[S.top] = 2;
S.top = S.top + 1;
S.data[S.top] = 3;
//可以写成以下形式
//前加加，先做加1，然后再去做后续的
S.data[++S.top] = 4;
//出栈
x = S.data[S.top];
S.top = S.top - 1;
//可以写成以下形式
//后减减
x = S.data[S.top--]
- 栈满
S.top等于MaxSize - 1时，栈满
2.4 栈的链表存储
（相对不重要，考的概率极低）
头部插入法和头部删除法
LiStack Lhead = (LiStack)malloc(sizeof(struct Linknode))
Lhead->next = NULL;
>top = (LiStack)malloc(sizeof(struct Linknode));
top->next = NULL;
top->data = 1;
top->next = Lhead->next;
Lhead->next = top;
元素出栈
c = top->data;
Lhead->next = top->next;
free(top);
top = Lhead->next;
栈空栈满
Lhead->next == NULL为真，则栈为空
只要存在剩余内存，那么栈就可以继续添加元素
3. 初始化栈 - 入栈 - 出栈实战
代码实战步骤（五步）：
初始化栈 - 判断栈是否为空 - 压栈 - 获取栈顶元素 - 弹栈。
注意：S.top为-1时，代表栈为空，每次先对S.top加1后，再放置元素
五个步骤分为五个子函数。
代码演示：
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 50
typedef int ElemType;
typedef struct {
ElemType data[MaxSize];//数组
int top;//始终指向栈顶的一个变量
}SqStack;
//初始化栈
void InitStack(SqStack& S)
{
S.top = -1;//初始化栈，让栈为空
}
//判断栈是否为空
bool StackEmpty(SqStack S)
{
if (-1 == S.top)
{
return true;
}
else
{
return false;
}
}
//入栈
bool Push(SqStack &S, ElemType x)
{
//判断栈是否满了
if (S.top == MaxSize - 1)
{
return false;
}
S.data[++S.top] = x;//等价于S.top = S.top + 1; S.data[S.top] = x;
return true;
}
//获取栈元素
bool GetTop(SqStack S, ElemType& m)
{
//判断栈是否为空
if (StackEmpty(S))
{
return false;
}
m = S.data[S.top];//拿栈顶元素
return true;
}
//弹出栈元素
bool Pop(SqStack& S, ElemType& m)
{
//判断栈是否为空
if (StackEmpty(S))
{
return false;
}
m = S.data[S.top--];//出栈 - 先m = S.data[S.top]; S.top = S.top - 1
return true;
}
int main()
{
SqStack S;
InitStack(S);
bool flag;
flag = StackEmpty(S);
if (flag)
{
printf("stack is empty\n");
}
Push(S, 3);//入栈元素3
Push(S, 4);//入栈元素4
Push(S, 5);//入栈元素5
ElemType m;
flag = GetTop(S, m);//获取栈顶元素
if (flag)
{
printf("获取栈顶元素为 %d\n", m);
}
flag = Pop(S, m);//弹出栈顶元素
if (flag)
{
printf("弹出栈顶元素为 %d\n", m);
}
flag = GetTop(S, m);//获取栈顶元素
if (flag)
{
printf("获取栈顶元素为 %d\n", m);
}
return 0;
}
运行结果：
4. 队列(Queue) - 循环队列原理解析
4.1 队列：只允许在一端进行插入，而在另一端进行删除的线性表
队列(queue)简称队；
也是一种操作受限
队的特点是：先进先出(First In First Out)
FIFO
4.2 队列的基本操作
队头(Front)。允许删除的一端，又称队首。
队尾(Rear)。允许插入的一端。
4.3 循环队列
#define MaxSize 6
typedef int ElemType;
typedef struct{
ElemType data[MaxSize];//数组，存储MaxSize - 1个元素
int front,rear;//队列头，队列尾
}SqQueue;
SqQueue Q;
- Q,front和Q,rear初始化为零，其相等时，循环队列为空。
- 放入一个元素后，Q.rear+1；
出队一个元素后，Q.front+1。 - 如果全部放满，Q.front和Q.rear相等，无法判断队满还是队空。
- (Q.rear + 1) % MaxSize == Q.front时，判断队满，牺牲一个存储单元。
循环数列元素入队
bool Enqueue(SqQueue &Q, ElemType x)
{
if ((Q.rear + 1) % MaxSize == Q.front)
return false;
Q.data[Q.rear] = x;//放入元素
Q.rear = (Q.rear + 1) % MaxSize;//改变队尾标记
return true;
}
循环数列元素出队
bool Enqueue(DeQueue &Q, ElemType x)
{
if (Q.rear == Q.front)
return false;
x = Q.data[Q.front];//先进先出
Q.front = (Q.front + 1) % MaxSize;
return true;/
}
4.4 队列的链式存储
队列的链式表示称为链队列，它实际上是一个同时带有队头指针和队尾指针的单链表。头指针指向队头结点，尾指针指向队尾结点，即单链表的最后一个结点。
存储结构
typedef int ElemType;
typedef struct LinkNode{
ElemType data;
struct LinkNode *next;
}LinkNode; //链表结点的结构体
typedef struct {
LinkNode *front, *rear; //链表头 链表尾
}LinkQueue; //先进先出
LinkQueue Q;
相对于原有编写的链表增加了尾指针
5. 循环队列实战
代码实战步骤（四步）：
初始化循环队列 - 判断循环队列是否为空 - 入队 - 出队
四个步骤分为四个子函数。
代码演示：
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 5
typedef int ElemType;
typedef struct {
ElemType data[MaxSize];//数组，存储MaxSize - 1个元素
int front, rear;//队列头 队列尾
}SqQueue;
void InitQueue(SqQueue& Q)
{
Q.front = Q.rear = 0;//初始化循环队列，就是让头和尾都指向零号
}
//判断循环队列是否为空
bool IsEmpty(SqQueue Q)
{
return Q.rear == Q.front;//相等时为空
}
//入队
bool EnQueue(SqQueue& Q, ElemType x)
{
if ((Q.rear + 1) % MaxSize == Q.front)//判断是否队满 - 满了就不能入队了
{
return false;
}
Q.data[Q.rear] = x;//放入元素3 4 5 6
Q.rear = (Q.rear + 1) % MaxSize;//rear要加1，如果大于数组最大下标，要回到开头
return true;
}
//出队
bool DeQueue(SqQueue& Q, ElemType& x)
{
if (Q.rear == Q.front)//队列为空，无法出队
{
return false;
}
x = Q.data[Q.front];//出队
Q.front = (Q.front + 1) % MaxSize;
return true;
}
//循环队列的代码实战
int main()
{
SqQueue Q;
bool ret;//存储返回值
ElemType element;//存储出队元素
InitQueue(Q);
ret = IsEmpty(Q);
if (ret)
{
printf("SqQueue is empty\n");
}
else
{
printf("SqQueue is not empty\n");
}
EnQueue(Q, 3);//入队3
EnQueue(Q, 4);
EnQueue(Q, 5);
ret = EnQueue(Q, 6);
ret = EnQueue(Q, 7);//队满，7无法入队
if (ret)
{
printf("EnQueue successful\n");
}
else
{
printf("EnQueue failed\n");
}
ret = DeQueue(Q, element);//出队
if (ret)
{
printf("DeQueue successful,element = %d\n",element);
}
else
{
printf("DeQueue failed\n");
}
ret = DeQueue(Q, element);//出队
if (ret)
{
printf("DeQueue successful,element = %d\n", element);
}
else
{
printf("DeQueue failed\n");
}
ret = EnQueue(Q, 8);//前面出队了元素，8可以入队
if (ret)
{
printf("EnQueue successful\n");
}
else
{
printf("EnQueue failed\n");
}
return 0;
}
运行结果：
6. 队列实战（通过链表实现）
代码实战步骤（三步）：
初始化队列 - 入队 - 出队
总结
2
- 头插法新建链表流程图：
3
- 尾插法新建链表流程图：
4
- 按位置查找流程图：
5
- 往第i个位置插入元素流程图：
6
- 链表中每一个结点在内存中是不连续的，通过单步调试，在变量窗口，依次点开头指针L，观察每一个结点是否符合自己的预期。
