前言:
在上篇文章中,我们简单介绍了两种基础数据结构——顺序表和单链表,今天我们就再来介绍两种简单的数据结构——栈和队列
1.栈
1.1栈的基本概念
- 栈(Stack)是只允许在一端进行插入或删除的线性表
- 栈顶:线性表中允许进行插入或删除的一端
- 栈底:线性表的另一端
- 栈是一种后进先出的线性表
物理结构如下图
1.2栈的实现
其实栈和我们前面说的顺序表结构差不多,区别就是栈只能在一端进行插入删除,所以我们话不多说,直接开始实现以下常用接口
typedef int STDataType;
typedef struct Stack
{
STDataType* _a;
int _top; // 栈顶
int _capacity; // 容量
}Stack;
// 初始化栈
void StackInit(Stack* ps);
// 入栈
void StackPush(Stack* ps, STDataType data);
// 出栈
void StackPop(Stack* ps);
// 获取栈顶元素
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数
int StackSize(Stack* ps);
// 检测栈是否为空
bool StackEmpty(Stack* ps);
// 销毁栈
void StackDestroy(Stack* ps);
(1)栈的初始化
// 初始化栈
void StackInit(Stack* ps) {
assert(ps);
ps->_a = NULL;
ps->_capacity = ps->_top = 0;
}
(2)入栈出栈
// 入栈
void StackPush(Stack* ps, STDataType data) {
assert(ps);
if (ps->_top == ps->_capacity) {
//由于我们初始化时没有给栈内存,所以我们这里使用三目操作符来开辟一下
int new_capacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
STDataType* tmp = (STDataType*)realloc(ps->_a, new_capacity * sizeof(STDataType));
if (tmp == NULL) {
perror("realloc fail");
return;
}
ps->_a = tmp;
ps->_capacity = new_capacity;
}
ps->_a[ps->_top] = data;
ps->_top++;
}
// 出栈
void StackPop(Stack* ps) {
assert(ps);
ps->_top--;
}
(3)取栈顶元素,获取栈中有效元素个数
// 获取栈顶元素
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;
}
(4)栈的判空和销毁
// 检测栈是否为空,如果为空返回非零结果,如果不为空返回0
bool 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;
}
2.队列
2.1队列的基本概念
- 和栈恰恰相反,队列(queue)是只允许在一段进行插入,而在另一端进行删除的结构
- 队列是一种先进先出的线性表
- 对尾:允许进行插入的一端
- 队头:允许进行删除的一端
- 队列的物理结构如下图
2.2队列的实现
队列可以用数组(顺序表)来实现,也可以用链表来实现,上文中栈的实现我们使用了顺序表,那队列我们就用链表来实现以下常用接口吧:
typedef int QDataType;
typedef struct QueNode {
QDataType val;
struct QueNode* next;
}Node;
typedef struct Queue {
Node* phead;//指向队头的指针
Node* ptail;//指向队尾的指针
int size;//用于记录队列中的数据个数
}Queue;
//队尾插入
void QueuePush(Queue*pq, QDataType x);
//队头删除
void QueuePop(Queue* pq);
//初始化
void QueueInit(Queue* pq);
//统计数据个数
int QueueSize(Queue* pq);
//销毁
void Distory(Queue* pq);
//判空
bool QueueEmpty(Queue* pq);
(1)初始化和销毁
//初始化
void QueueInit(Queue* pq) {
assert(pq);
pq->phead = NULL;
pq->ptail = NULL;
pq->size = 0;
}
//销毁
void Distory(Queue* pq) {
assert(pq);
Node* cur = pq->phead;
while (cur) {
Node* next = cur->next;
free(cur);
cur = next;
}
pq->phead = pq->ptail = NULL;
pq->size = 0;
}
(2)队尾插入,对头删除
//队尾插入
void QueuePush(Queue* pq, QDataType x) {
Node* tmp = (Node*)malloc(sizeof(Node));
if (tmp == NULL) {
perror("malloc");
}
tmp->val = x;
tmp->next = NULL;
if (pq->phead == NULL) {
pq->phead = pq->ptail = tmp;
}
else {
pq->ptail->next = tmp;
pq->ptail = tmp;
}
pq->size++;
}
//队头删除
void QueuePop(Queue* pq) {
assert(pq);
assert(pq->size != 0);
if (pq->phead->next == NULL) {
free(pq->phead);
pq->phead = pq->ptail = NULL;
pq->size--;
}
else {
Node* next = pq->phead->next;
free(pq->phead);
pq->phead = next;
if (pq->phead == NULL)
pq->ptail = NULL;
pq->size--;
}
}
(3)判空
//判空
bool QueueEmpty(Queue* pq) {
assert(pq);
return pq->size == 0;
}
结束!