一，栈
1，概念
栈 ：⼀种特殊的线性表，其只允许在固定的⼀端进⾏插⼊和删除元素操作 。进⾏数据插⼊和删除操作 的⼀端称为栈顶，另⼀端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
栈顶：允许进行插入和删除操作的一端。
栈底：固定的，不允许进行插入和删除操作的一端。
压栈 ：栈的插⼊操作叫做进栈/压栈/⼊栈，⼊数据在栈顶。
出栈 ：栈的删除操作叫做出栈。出数据也在栈顶。
这里我们举一个例子来理解栈的后进先出原则：
这里当我们依次把1，2，3压入栈中时，每次数据都放在栈顶，而出栈时我们要先从栈顶依次拿出数据，所以依次拿出3，2，1.
2，栈的底层结构
我们已经知道了栈的逻辑结构是线性表，那么栈的底层结构是什么？这里我们可以假设一下
栈的底层结构可以是数组，我们可以在数组的尾部实现栈的压栈和出栈操作
接下来我们从栈的几个操作和数组的适配度来看：
（1）入栈：只需要移动栈顶指针并赋值，数组的随机访问特性使得这个操作变得极快。
（2）出栈：只需要移动栈顶指针，同样可以利用数组的快速访问。
（3）取栈顶：直接返回栈顶指针指向的元素，即数组最后一个元素。
（4）判空：只需要返回栈顶指针的位置。
我们甚至可以发现栈的所有核心操作使用数组进行时，都可以在常数时间复杂度O（1）中完成，效率很高。
那当栈的底层结构能否是是链表呢？
答案是可以的，栈的底层结构是链表的时候，我们可以在头部进行插入和删除
那么两种底层结构之间有什么区别呢？
（1）内存 ：数组只需要存储数据本身，对于有n个数据的栈，用数组所需要的空间为n*sizeof（数据类型）。而链表在存储数据本身的同时还需要存储一个next指针，即所需空间为n*（sizeof（数据类型）+sizeof（指针））。所以使用链表作为底层结构时内存开销比数组要大。
（2）缓存性能：数组中的元素在空间中是连续存储的，访问速度较快。而链表在内存中是分散存储的，访问速度相比数组要慢。
通过上述比较我们可以发现，栈的实现⼀般可以使⽤数组或者链表实现，相对⽽⾔数组的结构实现更优⼀些。因为数组在尾上插⼊ 数据的代价⽐较⼩。
二，栈的实现
1，栈的定义
cpp
typedef int STDataType;
typedef struct Stack
{
STDataType* arr;//指向数组
int top;//指向栈顶的位置
int capacity;//容量
}ST;2，栈的初始化
cpp
void STInit(ST* ps)
{
ps->arr = NULL;
ps->top = ps->capacity = 0;
}3，栈的销毁
cpp
void STDestory(ST* ps)
{
if (ps->arr)
{
free(ps->arr);
}
ps->arr = NULL;
ps->top = ps->capacity = 0;
}4，入栈
cpp
void StackPush(ST* ps, STDataType x)
{
assert(ps);
if (ps->top == ps->capacity)
{
//空间不够---增容
int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
STDataType* tmp = (STDataType*)realloc(ps->arr, newCapacity * sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail!");
exit(1);
}
ps->arr = tmp;
ps->capacity = newCapacity;
}
//空间足够
ps->arr[ps->top++] = x;
}5，判空
cpp
bool StackEmpty(ST* ps)
{
assert(ps);
return ps->top == 0;
}6，出栈
cpp
void StackPop(ST* ps)
{
assert(!StackEmpty(ps));
--ps->top;
}7，取栈顶元素
cpp
STDataType StackTop(ST* ps)
{
assert(!StackEmpty(ps));
return ps->arr[ps->top - 1];
}8，获取栈中有效元素个数
cpp
int STSize(ST* ps)
{
assert(ps);
return ps->top;
}三，栈的例题
1，有效括号问题
题目描述：
思路：
借助数据结构栈，遍历字符串，左括号入栈，遇到右括号就跟栈顶元素比较，看看是否匹配
题解：
cpp
typedef int STDataType;
typedef struct Stack
{
STDataType* arr;
int top; //指向栈顶的位置
int capacity; //容量
}ST;
void STInit(ST* ps)
{
ps->arr = NULL;
ps->top = ps->capacity = 0;
}
void STDestroy(ST* ps)
{
if (ps->arr)
free(ps->arr);
ps->arr = NULL;
ps->top = ps->capacity = 0;
}
//入栈----栈顶
void StackPush(ST* ps, STDataType x)
{
assert(ps);
if (ps->top == ps->capacity)
{
//空间不够---增容
int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
STDataType* tmp = (STDataType*)realloc(ps->arr, newCapacity * sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail!");
exit(1);
}
ps->arr = tmp;
ps->capacity = newCapacity;
}
//空间足够
ps->arr[ps->top++] = x;
}
bool StackEmpty(ST* ps)
{
assert(ps);
return ps->top == 0;
}
//出栈----栈顶
void StackPop(ST* ps)
{
assert(!StackEmpty(ps));
--ps->top;
}
//取栈顶数据
STDataType StackTop(ST* ps)
{
assert(!StackEmpty(ps));
return ps->arr[ps->top - 1];
}
//获取栈中有效元素个数
int STSize(ST* ps)
{
assert(ps);
return ps->top;
}
bool isValid(char* s)
{
ST st;
STInit(&st);
char* pi=s;
while(*pi!='\0')
{
if(*pi=='('||*pi=='['||*pi=='{')
{
StackPush(&st,*pi);
}
else
{
if(StackEmpty(&st))
{
STDestroy(&st);
return false;
}
char top=StackTop(&st);
if((top=='('&&*pi!=')')||(top=='['&&*pi!=']')||(top=='{'&&*pi!='}'))
{
STDestroy(&st);
return false;
}
StackPop(&st);
}
pi++;
}
bool ret=StackEmpty(&st)?true:false;
STDestroy(&st);
return ret;
}四，队列
概念：只允许在⼀端进⾏插⼊数据操作，在另⼀端进⾏删除数据操作的特殊线性表，队列具有先进先 出FIFO(First In First Out)
入队列：进⾏插⼊操作的⼀端称为队尾
出队列：进⾏删除操作的⼀端称为队头
底层结构：
队列也可以数组和链表的结构实现，使⽤链表的结构实现更优⼀些，因为如果使⽤数组的结构，出队 列在数组头上出数据，效率会⽐较低。
两者差别：
数组：使用数组时，队列的出队和入队的时间复杂度都是为O(1)，随机访问的复杂度为O(1),因为我们可以下标访问。
链表：使用链表时，链表的出队和入队的时间复杂度均是O(1),随机访问的时间负责都却为O(n)，因为链表不能单独通过下标访问，需要遍历。
内存占用上，数组内存大小时固定的，或者动态2倍扩容（代价较大），但是链表的每个节点需要额外的指针。
因此，在容量可以预估，需要频繁访问的时候使用数组作为底层结构最好。而容量不确定，需要动态增长的时候使用链表更好。
五，队列的实现
1，队列节点结构
cpp
typedef int QDataTpe;
typedef struct QueueNode
{
QDataTpe data;
struct QueueNode* next;
}QueueNode;2，队列结构
cpp
typedef struct Queue {
QueueNode* phead;//队头
QueueNode* ptail;//队尾
int size;//记录有效数据个数
}Queue;3，初始化队列
cpp
void QueueInit(Queue* pq)
{
assert(pq);
pq->phead = pq->ptail = NULL;
}4，销毁队列
cpp
void QueueDestroy(Queue* pq)
{
assert(pq);
QueueNode* pcur = pq->phead;
while (pcur)
{
QueueNode* next = pcur->next;
free(pcur);
pcur = next;
}
pq->phead = pq->ptail = NULL;
}5，入队列
cpp
void QueuePush(Queue* pq, QDataTpe x)
{
assert(pq);
//newnode
QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
if (newnode == NULL)
{
perror("malloc fail!");
exit(1);
}
newnode->data = x;
newnode->next = NULL;
//队列为空，newnode是队头也是队尾
if (pq->phead == NULL)
{
pq->phead = pq->ptail = newnode;
}
else {
//队列非空，直接插入到队尾
pq->ptail->next = newnode;
pq->ptail = pq->ptail->next;
}
pq->size++;
}6，判空
cpp
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->phead == 0;
}7，出队列
cpp
void QueuePop(Queue* pq)
{
assert(!QueueEmpty(pq));
//只有一个结点的情况
if (pq->phead == pq->ptail)
{
free(pq->phead);
pq->phead = pq->ptail = NULL;
}
else {
QueueNode* next = pq->phead->next;
free(pq->phead);
pq->phead = next;
}
pq->size--;
}8，取队头数据
cpp
QDataTpe QueueFront(Queue* pq)
{
assert(!QueueEmpty(pq));
return pq->phead->data;
}9，取队尾数据
cpp
QDataTpe QueueBack(Queue* pq)
{
assert(!QueueEmpty(pq));
return pq->ptail->data;
}六，队列编程题
1，用队列实现栈
解题思路：栈是先进后出而队列是先进先出。
入栈：往不为空的队列中插入数据
出栈：把不为空队列中前size-1个数据挪到另一个队列，再将该队列中最后一个元素出队列
取栈顶元素（不出数据）：取不为空队列中的队尾数据。
解题代码：
cpp
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
typedef int QDataType;
typedef struct QueueNode
{
QDataType data;
struct QueueNode* next;
}QueueNode;
typedef struct Queue {
QueueNode* phead;
QueueNode* ptail;
int size;
}Queue;
void QueueInit(Queue* pq)
{
assert(pq);
pq->phead = pq->ptail = NULL;
pq->size = 0; // 添加这行，初始化size为0
}
void QueueDestroy(Queue* pq)
{
assert(pq);
QueueNode* pcur = pq->phead;
while (pcur)
{
QueueNode* next = pcur->next;
free(pcur);
pcur = next;
}
pq->phead = pq->ptail = NULL;
pq->size = 0; // 重置size
}
void QueuePush(Queue* pq, QDataType x)
{
assert(pq);
QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
if (newnode == NULL)
{
perror("malloc fail!");
exit(1);
}
newnode->data = x;
newnode->next = NULL;
if (pq->phead == NULL)
{
pq->phead = pq->ptail = newnode;
}
else {
pq->ptail->next = newnode;
pq->ptail = pq->ptail->next;
}
pq->size++;
}
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->phead == NULL; // 修正这里
}
void QueuePop(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq)); // 确保队列不为空
// 只有一个结点的情况
if (pq->phead == pq->ptail)
{
free(pq->phead);
pq->phead = pq->ptail = NULL;
}
else {
QueueNode* next = pq->phead->next;
free(pq->phead);
pq->phead = next;
}
pq->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;
}
int QueueSize(Queue* pq)
{
assert(pq);
return pq->size;
}
// 栈结构定义
typedef struct {
Queue q1;
Queue q2;
} MyStack;
MyStack* myStackCreate() {
MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
if (pst == NULL) {
perror("malloc fail!");
exit(1);
}
QueueInit(&pst->q1);
QueueInit(&pst->q2);
return pst;
}
bool myStackEmpty(MyStack* obj) {
assert(obj);
return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}
void myStackPush(MyStack* obj, int x) {
assert(obj);
// 总是推入非空队列（如果都为空，推入q1）
if (!QueueEmpty(&obj->q1)) {
QueuePush(&obj->q1, x);
} else {
QueuePush(&obj->q2, x);
}
}
int myStackPop(MyStack* obj) {
assert(obj);
assert(!myStackEmpty(obj)); // 确保栈不为空
// 找出空队列和非空队列
Queue* emptyQueue = &obj->q1;
Queue* nonEmptyQueue = &obj->q2;
if (!QueueEmpty(&obj->q1)) {
emptyQueue = &obj->q2;
nonEmptyQueue = &obj->q1;
}
// 将非空队列的前n-1个元素转移到空队列
while (QueueSize(nonEmptyQueue) > 1) {
QDataType front = QueueFront(nonEmptyQueue);
QueuePush(emptyQueue, front);
QueuePop(nonEmptyQueue);
}
// 最后一个元素就是栈顶元素
int top = QueueFront(nonEmptyQueue);
QueuePop(nonEmptyQueue);
return top;
}
int myStackTop(MyStack* obj) {
assert(obj);
assert(!myStackEmpty(obj)); // 确保栈不为空
// 返回非空队列的队尾元素
if (!QueueEmpty(&obj->q1)) {
return QueueBack(&obj->q1);
} else {
return QueueBack(&obj->q2);
}
}
void myStackFree(MyStack* obj) {
if (obj == NULL) return;
QueueDestroy(&obj->q1);
QueueDestroy(&obj->q2);
free(obj);
}2，用栈实现队列
解题思路：栈先进后出，队列先进先出，需要两个栈。
关键在于如何反转元素的顺序
使用两个栈，pushST为入队栈，popST为出队栈。
入队：往pushST中插入数据。
出队：popST不为空直接出数据，否则就将pushST中的数据导入到popST后再出数据。
经过这样一次转移，元素的顺序就被反转了。
取队头：逻辑同出队操作，但是这里只取数据不POP.
判断队列为空：两个栈都为空。
题解：
cpp
typedef int STDataType;
typedef struct Stack
{
STDataType* arr;
int top; //指向栈顶的位置
int capacity; //容量
}ST;
void STInit(ST* ps)
{
ps->arr = NULL;
ps->top = ps->capacity = 0;
}
void STDestroy(ST* ps)
{
if (ps->arr)
free(ps->arr);
ps->arr = NULL;
ps->top = ps->capacity = 0;
}
//入栈----栈顶
void StackPush(ST* ps, STDataType x)
{
assert(ps);
if (ps->top == ps->capacity)
{
//空间不够---增容
int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
STDataType* tmp = (STDataType*)realloc(ps->arr, newCapacity * sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail!");
exit(1);
}
ps->arr = tmp;
ps->capacity = newCapacity;
}
//空间足够
ps->arr[ps->top++] = x;
}
bool StackEmpty(ST* ps)
{
assert(ps);
return ps->top == 0;
}
//出栈----栈顶
void StackPop(ST* ps)
{
assert(!StackEmpty(ps));
--ps->top;
}
//取栈顶数据
STDataType StackTop(ST* ps)
{
assert(!StackEmpty(ps));
return ps->arr[ps->top - 1];
}
//获取栈中有效元素个数
int STSize(ST* ps)
{
assert(ps);
return ps->top;
}
typedef struct {
ST pushST;
ST popST;
} MyQueue;
MyQueue* myQueueCreate() {
MyQueue* pq=(MyQueue*)malloc(sizeof(MyQueue));
STInit(&pq->pushST);
STInit(&pq->popST);
return pq;
}
bool myQueueEmpty(MyQueue* obj) {
return StackEmpty(&obj->pushST)&&StackEmpty(&obj->popST);
}
void myQueuePush(MyQueue* obj, int x) {
//往pushST中插入数据
StackPush(&obj->pushST,x);
}
//检查popST是否为空
//1）不为空，取栈顶
//2）为空，pushST倒入到popST中，再取popST的栈顶
int myQueuePop(MyQueue* obj) {
if(StackEmpty(&obj->popST))
{
//导数据
while(!StackEmpty(&obj->pushST))
{
StackPush(&obj->popST,StackTop(&obj->pushST));
StackPop(&obj->pushST);
}
}
//popST不为空
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);
}
}
//popST不为空
return StackTop(&obj->popST);
}
void myQueueFree(MyQueue* obj) {
STDestroy(&obj->pushST);
STDestroy(&obj->popST);
free(obj);
obj=NULL;
}3，设计循环队列
题目描述：
循环队列：
1，概念：实际中还有⼀种特殊的队列叫循环队列，环形队列⾸尾相连成环，环形队列可以使⽤数组实现，也可 以使⽤循环链表实现。
队列满的情况下，为什么 Q.rear 不存储数据？
为了能使⽤ Q.rear = Q.front 来区别是队空还是队满，我们常常认为出现左图时的情况即为队满 的情况，此时： rear+1=front。
首先我们要思考为什么需要循环队列？
因为普通队列会存在假溢出问题：当队尾指针到达数组末尾时，即使队首前面还有空位，也无法插入新元素。
那么我们需要将数组逻辑上视为环形，当队尾到达末尾的时候，可以回到开头继续存储。
如何区分队空和队满？
方案一：牺牲一个存储单元
队空条件：front==rear
队满条件：(rear+1)%capacity==front
实际可存储元素个数：capacity-1
方案二：额外记录队列长度
队空条件：size==0
队满条件：size==capacity
cpp
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
typedef struct {
int* arr; // 存储数据的数组
int front; // 队首指针（指向队首元素）
int rear; // 队尾指针（指向队尾元素的下一个位置）
int capacity; // 队列总容量（包含牺牲的空间）
} MyCircularQueue;
// 创建循环队列，设置长度为k
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
if (obj == NULL) {
perror("malloc fail!");
exit(1);
}
// 需要牺牲一个空间来区分队空和队满，所以实际容量为k+1
obj->capacity = k + 1;
obj->arr = (int*)malloc(sizeof(int) * obj->capacity);
if (obj->arr == NULL) {
perror("malloc fail!");
exit(1);
}
obj->front = 0; // 初始时队首指向0
obj->rear = 0; // 初始时队尾指向0（空队列）
return obj;
}
// 检查循环队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
// 队空条件：front == rear
return obj->front == obj->rear;
}
// 检查循环队列是否已满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
// 队满条件：(rear + 1) % capacity == front
return (obj->rear + 1) % obj->capacity == obj->front;
}
// 向循环队列插入一个元素
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
// 检查队列是否已满
if (myCircularQueueIsFull(obj)) {
return false; // 队列满，插入失败
}
// 在rear位置插入元素
obj->arr[obj->rear] = value;
// rear指针后移，因为是循环，需要对capacity取模
obj->rear = (obj->rear + 1) % obj->capacity;
return true; // 插入成功
}
// 从循环队列中删除一个元素
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
// 检查队列是否为空
if (myCircularQueueIsEmpty(obj)) {
return false; // 队列空，删除失败
}
// front指针后移，队首元素被逻辑删除
obj->front = (obj->front + 1) % obj->capacity;
return true; // 删除成功
}
// 获取队首元素
int myCircularQueueFront(MyCircularQueue* obj) {
if (myCircularQueueIsEmpty(obj)) {
return -1; // 队列空，返回-1
}
return obj->arr[obj->front];
}
// 获取队尾元素
int myCircularQueueRear(MyCircularQueue* obj) {
if (myCircularQueueIsEmpty(obj)) {
return -1; // 队列空，返回-1
}
// 队尾元素在rear的前一个位置
// 因为rear指向的是下一个要插入的位置
// 需要处理rear=0的特殊情况（环形）
int rearIndex = (obj->rear - 1 + obj->capacity) % obj->capacity;
return obj->arr[rearIndex];
}
// 释放循环队列
void myCircularQueueFree(MyCircularQueue* obj) {
if (obj) {
free(obj->arr);
free(obj);
}
}