目录
栈
栈的概念
栈的实现
队列
队列的概念
队列的实现
栈
栈的概念
栈是一种后进先出 (LIFO - last in first out) 的数据结构，通常利用数组或链表实现。栈只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出原则。
它的基本操作包括 push (将元素压入栈中) 和 pop (将栈顶元素弹出)。栈还可以支持其它一些常见操作，例如：peek - 查看栈顶元素但不弹出、isEmpty - 判断栈是否为空、size - 获取栈中元素的个数。栈的抽象图例如下。
其实可以把栈形象的想象成一个瓶子（上面开口下面封闭的那种）。进栈的操作就相当于往瓶子中放东西，而出栈操作就相当于从瓶子中倒东西，而且不论是哪种操作，其只能在瓶口的那一端进行操作，没有办法操作瓶底或者其它位置。这样，这种先进后出的栈结构就很好理解了。
栈的实现
栈的实现有两种，一种是顺序表，一种是链表。这两种方式中顺序表要更方便一些，因为栈是一种只在一端进行操作的数据结构，不支持随机位置操作。而链表比顺序表的优势就是随机位置操作要更快，而且链表的维护成本要比顺序表大（因为顺序表就是数组嘛），所以用顺序表的尾插、尾删来实现栈的入栈和出栈是一种很便捷的方式。
栈的实现不难，但不同的人实现的方式也是各式各样的，所以就不再赘述了。如果需要，可以参考下面的代码。（小白本人是用顺序表实现的，但也可以用链表实现，这个很灵活）
// 初始化栈
void StackInit(Stack* ps)
{
assert(ps != NULL);
ps->_a = NULL;
ps->_capacity = 0;
ps->_top = -1;
}
//数组扩容
void Expansion(Stack* ps)
{
ps->_a = (STDataType*)realloc(ps->_a, (ps->_capacity + 1) * 2 * sizeof(STDataType));
assert(ps->_a != NULL);
ps->_capacity = (ps->_capacity + 1) * 2;
}
// 入栈
void StackPush(Stack* ps, STDataType data)
{
assert(ps != NULL);
//需要扩容的情况
if (ps->_top + 1 == ps->_capacity)
Expansion(ps);
ps->_a[++ps->_top] = data;
}
// 出栈
void StackPop(Stack* ps)
{
assert(ps != NULL);
assert(!StackEmpty(ps));
ps->_top--;
}
// 获取栈顶元素
STDataType StackTop(Stack* ps)
{
assert(ps != NULL);
assert(!StackEmpty(ps));
return ps->_a[ps->_top];
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps)
{
assert(ps); //这句断言其实可以不要，但为了严谨还是写上
return ps->_top == -1;
}
// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
assert(ps != NULL);
return ps->_top + 1;
}
// 销毁栈
void StackDestroy(Stack* ps)
{
assert(ps != NULL);
free(ps->_a);
ps->_capacity = 0;
ps->_top = -1;
}队列
队列的概念
队列是一种先进先出（FIFO - first in first out）的数据结构，类似于排队等候的场景。队列只允许在一端进行插入数据操作，在另一端进行删除数据操作
它有两个基本操作：入队和出队。入队操作将一个元素插入到队列的末尾，出队操作从队列的开头删除一个元素。因为元素是按照先进先出的顺序被处理，所以队列能够确保处理的顺序是正确的。
队列的实现
队列的实现也是有顺序表和链表两种实现方式，如果是单调队列用链表会方便些，而双向循环队列用顺序表又比较方便。具体原因是因为：单调队列要对头和尾进行操作，如果是顺序表的话需要移动元素（删除之后要移动元素），实现起来会很麻烦，而链表的话直接跳过一个指针就可以了。而双向循环链表的如果用链表实现会比较麻烦，首先用循环链表的话操作更麻烦一些，维护要比顺序表的成本大，其次用顺序表空间利用率和时间利用率都要比用链表优秀一些。而且可以实现不用一次性移动很多数据的出队列操作，所以相比之下，顺序表是个很不错的选择。
队列的实现也不难，不同的人实现的方式也是各式各样的，所以就不再赘述了。如果需要，可以参考下面的代码。
- 单调队列
// 初始化队列
void QueueInit(Queue* q)
{
//带头节点的实现
assert(q != NULL);
q->_front = (QNode*)malloc(sizeof(QNode));
assert(q->_front != NULL);
q->_front->_next = NULL;
q->_rear = q->_front;
}
// 队尾入队列
void QueuePush(Queue* q, QDataType data)
{
assert(q != NULL);
q->_rear->_next = (QNode*)malloc(sizeof(QNode));
QNode* newNode = q->_rear->_next;
assert(newNode != NULL);
newNode->_data = data;
newNode->_next = NULL;
q->_rear = newNode;
}
// 队头出队列
void QueuePop(Queue* q)
{
assert(q != NULL);
assert(!QueueEmpty(q));
QNode* tmp = q->_front->_next;
q->_front->_next = tmp->_next;
if (tmp->_next == NULL)
q->_rear = NULL;
free(tmp);
}
// 获取队列头部元素
QDataType QueueFront(Queue* q)
{
assert(q != NULL);
assert(!QueueEmpty(q));
return q->_front->_next->_data;
}
// 获取队列队尾元素
QDataType QueueBack(Queue* q)
{
assert(q != NULL);
assert(!QueueEmpty(q));
return q->_rear->_data;
}
// 获取队列中有效元素个数
int QueueSize(Queue* q)
{
QNode* cur = q->_front->_next;
int size = 0;
while (cur)
{
cur = cur->_next;
size++;
}
return size;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
int QueueEmpty(Queue* q)
{
assert(q != NULL);
return q->_front->_next == q->_rear && q->_rear == NULL;
}
// 销毁队列
void QueueDestroy(Queue* q)
{
assert(q != NULL);
QNode* cur = q->_front->_next;
while (cur)
{
QNode* next = cur->_next;
free(cur);
cur = next;
}
q->_front->_next = NULL;
q->_rear = NULL;
}- 循环队列
循环队列参考一道leetcode的题
622. 设计循环队列 - 力扣（LeetCode）
https://leetcode.cn/problems/design-circular-queue/
typedef struct
{
int* queueArray;
int front;
int rear;
int size;
int capacity;
} MyCircularQueue;
MyCircularQueue* myCircularQueueCreate(int k)
{
MyCircularQueue* cirQueue = (MyCircularQueue*) malloc (sizeof(MyCircularQueue));
cirQueue->front = 0;
cirQueue->rear = -1;
cirQueue->size = 0;
cirQueue->capacity = k;
cirQueue->queueArray = (int*) calloc (k, sizeof(MyCircularQueue));
return cirQueue;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj)
{
return obj->size == 0;
}
bool myCircularQueueIsFull(MyCircularQueue* obj)
{
return obj->size == obj->capacity;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value)
{
int k = obj->capacity;
if(!myCircularQueueIsFull(obj))
{
obj->rear = (obj->rear + 1) % k;
obj->queueArray[obj->rear] = value;
obj->size++;
return true;
}
return false;
}
bool myCircularQueueDeQueue(MyCircularQueue* obj)
{
int k = obj->capacity;
if(!myCircularQueueIsEmpty(obj))
{
obj->front = (obj->front + 1) % k;
obj->size--;
return true;
}
return false;
}
int myCircularQueueFront(MyCircularQueue* obj)
{
if(!myCircularQueueIsEmpty(obj))
return obj->queueArray[obj->front];
return -1;
}
int myCircularQueueRear(MyCircularQueue* obj)
{
if(!myCircularQueueIsEmpty(obj))
return obj->queueArray[obj->rear];
return -1;
}
void myCircularQueueFree(MyCircularQueue* obj)
{
free(obj->queueArray);
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);
*/
