【数据结构】栈与队列（以C语言为基础）

前言

栈与队列是什么？

栈与队列其实都是线性表一种特殊形式，相较于普通的线性表，栈和队列其实并没有变复杂，反而操作受到了限制。一言以蔽之——“栈和队列是操作受限的线性表”

为什么要学栈与队列？

栈与队列将数组或链表的操作封装，让我们处理问题时不必纠结于诸如数组下标，链表链接等细节，而着眼于问题中更关键的部分。

栈

概念与结构

栈：栈只允许在一端进行插入和删除操作。 进行插入和删除元素的一端叫做栈顶，另一端叫做栈底。 栈遵循后进先出LIFO（Last In Fast Out）的规则。

入栈：栈的插入元素的操作叫做入栈/进栈/压栈，即入元素在栈顶
出栈：栈的删除元素的操作叫做出栈，即出元素也在栈顶
空栈：不含任何元素的空表。

栈的实现

栈一般可以用数组和链表实现，用数组实现的叫顺序栈，用链表实现的叫链栈。相对而言，数组结构更加方便常用，因为数组的尾插代价更小。

基本功能

作为一个栈，一般有以下几个功能：
初始化，入栈，出栈，获取栈顶元素，获取有效元素个数，判空，销毁栈

// 初始化栈 
void StackInit(Stack* ps);
// 入栈 
void StackPush(Stack* ps, STDataType data);
// 出栈 
void StackPop(Stack* ps);
// 获取栈顶元素 
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数 
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);

具体实现

// 支持动态增长的栈
//typedef int STDataType;
//typedef struct Stack
//{
//	STDataType* _a;
//	int _top;		// 栈顶
//	int _capacity;  // 容量 
//}Stack;

// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a = NULL;
	ps->_top = ps->_capacity = 0;
}
// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	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)
		{
			perror("relloc fail");
			exit(-1);
		}
		ps->_a = tmp;
		ps->_capacity = newcapacity;
	}
	ps->_a[ps->_top] = data;
	ps->_top++;
}
// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->_top>0);
	ps->_top--;
}
// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->_top > 0);
	return ps->_a[ps->_top-1];
}
// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->_top == 0;
}
// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_top = ps->_capacity = 0;
}

栈的常见用途——递归

什么是递归？

递归就是一种分治思想，可以把一个大问题分解为几个类似形式的小问题，然后对小问题继续进行拆分，直到不能再拆（达到边界条件）。例如著名的斐波那契数列，汉诺塔问题等。

用栈实现非递归

我们常常听到 “用栈实现非递归” 的说法，其实准确而言是 “用栈实现非（函数形式）递归”。
我们在学C语言的函数时，学到过用函数实现递归。函数实现递归时系统会开辟栈帧，进行一系列诸如压栈和出栈等操作。不过用函数进行递归，会造成巨大的时间开销和空间开销。所以，我们可以用人工栈来代替系统栈来避免上述问题。

队列

概念与结构

队列：队列是只能从一端进行插入操作，另一端进行删除操作的线性表。队列遵循先进先出
FIFO(First In First Out) 的规则。

队尾：进行插入操作的一端叫做队尾。
队头：进行删除操作的一段叫做队头。
空队列：不含任何元素的空表。

队列的实现

队列也可以用数组和链表实现，而数组的出队会比较麻烦，所以我们一般用链表来实现队列。

基本功能

作为一个队列，一般有一下几个功能：
初始化，入队，出队，获取队头元素，获取队尾元素，获取有效元素个数，判空，销毁队列

// 初始化队列 
void QueueInit(Queue* q);
// 队尾入队列 
void QueuePush(Queue* q, QDataType data);
// 队头出队列 
void QueuePop(Queue* q);
// 获取队列头部元素 
QDataType QueueFront(Queue* q);
// 获取队列队尾元素 
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数 
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);

具体实现

 链式结构：表示队列 
//typedef struct QListNode
//{
//	struct QListNode* _next;
//	QDataType _data;
//}QNode;

// 队列的结构 
//typedef struct Queue
//{
//	QNode* _front;
//	QNode* _rear;
// 	int _size;
//}Queue;

// 初始化队列 
void QueueInit(Queue* q)
{
	assert(q);
	q->_rear = q->_front = NULL;
	q->_size = 0;
}
// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->_data = data;
	newnode->_next = NULL;
	if (q->_rear)
	{
		q->_rear->_next = newnode;
		q->_rear = newnode;
	}
	else
	{
		q->_rear = q->_front = newnode;
	}
	q->_size++;
}
// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	if(q->_front->_next)
	{
		QNode* next = q->_front->_next;
		free(q->_front);
		q->_front = next;
	}
	else
	{
		free(q->_front);
		q->_front = q->_rear = NULL;
	}
	q->_size--;
}
// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->_front->_data;
}
// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->_rear->_data;
}
// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);
	return q->_size;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
	assert(q);
	return q->_front == NULL;

}
// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	while (q->_front)
	{
		QNode* next = q->_front->_next;
		free(q->_front);
		q->_front = next;
	}
	q->_front = q->_rear = NULL;
	q->_size = 0;
}

循环队列（环形缓冲区ring buffer）

循环队列用链表和数组均可实现，用数组更优。

ringbuffer的好处及作用

1.不需要频繁的分配和释放内存，可以重复使用内存块，减少内存的浪费。
2.头尾相连的结构使得数据可以循环存储，可以更好地缓存数据流。
3.对于进程间通信和网络IO等场景，环形缓冲区可以提供对缓冲区的互斥访问，保证数据的安全性。
4.可以通过计数来判断缓冲区是否为空或已满，方便管理和控制缓冲区的状态。
5.环形缓冲区的实现相对简单，易于理解和维护。

循环队列的实现

循环队列重点要掌握的是“循环”的实现方法
一般来说，我们可以使用取模的方式来进行循环
如：
设front为队头下标，rear为队尾下标，k为循环队列最大容量（注意：为了方便判空，我们多申请了一个空间，即k+1个空间，但这个空间不存数据）
初始时：front = rear=0。
队首指针进1：front %= (k + 1)
队尾指针进1：rear%= (k + 1)
队满条件：(rear + 1)% (k+1)== front
队空条件：front == rear
队列中有效元素的个数： ( rear - front + k+1 ) % (k+1)
这里给出一种常见的循环队列的实现方法：

#include<stdbool.h>

//MyCircularQueue(k) : 构造器，设置队列长度为 k 。
//Front : 从队首获取元素。如果队列为空，返回 - 1 。
//Rear : 获取队尾元素。如果队列为空，返回 - 1 。
//enQueue(value) : 向循环队列插入一个元素。如果成功插入则返回真。
//deQueue() : 从循环队列中删除一个元素。如果成功删除则返回真。
//isEmpty() : 检查循环队列是否为空。
//isFull() : 检查循环队列是否已满。
typedef int CQData;
typedef struct {
    CQData* a;
    int front;
    int rear;
    int k;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (CQData*)malloc(sizeof(CQData) * (k + 1));
    //多开一个空间方便区分空和满
    obj->front = obj->rear = 0;
    obj->k = k;
    return obj;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->rear == obj->front;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    //return obj->rear+1==obj->front;
    //错误
    return (obj->rear + 1) % (obj->k + 1) == obj->front;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (myCircularQueueIsFull(obj))
        return false;
    obj->a[obj->rear] = value;
    obj->rear++;
    obj->rear %= (obj->k + 1);
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
        return false;
    obj->front++;
    obj->front %= (obj->k + 1);
    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;
    return obj->a[(obj->rear + obj->k) % (obj->k + 1)];
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}
//有效数据长度
int myCircularQueueLenth(MyCircularQueue* obj)
{
    return (obj->rear - obj->front + obj->k + 1) % (obj->k + 1);
}

相关leetcode题：设计循环队列