栈和队列讲解和实现
文章目录
- 一.栈
-
- (1).初始化栈
- (2).入栈
- (3).出栈
- (4).获取栈顶元素
- (5).获取栈中有效元素个数
- (6). 检测栈是否为空，如果为空返回true,非空返回false
- (7).销毁栈
- (8).完整代码实现
- 二.队列
-
- (1).初始化队列
- (2).入队列
- (3).出队列
- (4).获取队列头部元素
- (5).获取队列队尾元素
- (6).获取队列中有效元素个数
- (7).检测队列是否为空，如果为空返回true,非空为false
- (8). 销毁队列
- (9).完整代码实现
一.栈
栈: 一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据也在栈顶。
Stack.h中部分声明
#include(1).初始化栈
(1).给栈动态开辟一块内存空间
(2).设置栈顶下标为0,即栈顶下标 top 代表栈中有效元素的个数
(3).设置栈的起始容量
void StackInit(Stack* pst)
{
assert(pst);
pst->a = (STDataType*)malloc(sizeof(STDataType) * INIT_CAPACITY);
if (pst->a == NULL)
{
printf("malloc failed\n");
exit(-1);
}
pst->top = 0;
pst->capacity = INIT_CAPACITY;
}
(2).入栈
(1).若栈空间已满，使用realloc函数动态增容
(2).将入栈的数据放入栈中
(3).栈顶下标+1
void StackPush(Stack* pst, STDataType x)
{
assert(pst);
// 动态增容
if (pst->top == pst->capacity)
{
pst->capacity *= 2;
STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType) * pst->capacity);
if (tmp == NULL)
{
printf("realloc failed\n");
exit(-1);
}
pst->a = tmp;
}
pst->a[pst->top] = x;
pst->top++;
}
(3).出栈
(1).判断栈是否为空
(2).栈顶下标-1
void StackPop(Stack* pst)
{
assert(pst);
assert(!StackEmpty(pst));
pst->top--;
}
(4).获取栈顶元素
(1).判断栈是否为空
(2).获取栈顶元素
STDataType StackTop(Stack* pst)
{
assert(pst);
assert(!StackEmpty(pst));
return pst->a[pst->top - 1];
}
(5).获取栈中有效元素个数
栈顶下标即为栈中有效元素个数
int StackSize(Stack* pst)
{
assert(pst);
return pst->top;
}
(6). 检测栈是否为空，如果为空返回true,非空返回false
由于栈顶下标代表栈中有效元素个数,所以只需判断栈顶下标是否为0即可
bool StackEmpty(Stack* pst)
{
assert(pst);
return pst->top == 0;
}
(7).销毁栈
(1).将栈顶下标和栈的容量置为0
(2).释放掉动态开辟的内存空间
void StackDestroy(Stack* pst)
{
assert(pst);
pst->top = pst->capacity = 0;
free(pst->a);
pst->a = NULL;
}
(8).完整代码实现
Stack.h
#pragma once
#includeStack.c
#include"Stack.h"
// 打印
void print(Stack* pst)
{
assert(pst);
int i = 0;
for (i = 0; i < pst->top; i++)
{
printf("%d ", pst->a[i]);
}
printf("\n");
}
// 判断栈是否为空，为空返回true,非空返回false
bool StackEmpty(Stack* pst)
{
assert(pst);
return pst->top == 0;
}
// 栈的初始化
void StackInit(Stack* pst)
{
assert(pst);
pst->a = (STDataType*)malloc(sizeof(STDataType) * INIT_CAPACITY);
if (pst->a == NULL)
{
printf("malloc failed\n");
exit(-1);
}
pst->top = 0;
pst->capacity = INIT_CAPACITY;
}
// 入栈
void StackPush(Stack* pst, STDataType x)
{
assert(pst);
// 动态增容
if (pst->top == pst->capacity)
{
pst->capacity *= 2;
STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType) * pst->capacity);
if (tmp == NULL)
{
printf("realloc failed\n");
exit(-1);
}
pst->a = tmp;
}
pst->a[pst->top] = x;
pst->top++;
}
// 出栈
void StackPop(Stack* pst)
{
assert(pst);
assert(!StackEmpty(pst));
pst->top--;
}
// 获取栈顶元素
STDataType StackTop(Stack* pst)
{
assert(pst);
assert(!StackEmpty(pst));
return pst->a[pst->top - 1];
}
// 获取栈的元素个数
int StackSize(Stack* pst)
{
assert(pst);
return pst->top;
}
// 销毁栈
void StackDestroy(Stack* pst)
{
assert(pst);
pst->top = pst->capacity = 0;
free(pst->a);
pst->a = NULL;
}
TestStack.c
#include"Stack.h"
void TestStack01()
{
Stack st;
StackInit(&st);
StackPush(&st, 1);
StackPush(&st, 2);
StackPush(&st, 3);
StackPush(&st, 4);
print(&st);
StackPop(&st);
print(&st);
StackPop(&st);
StackPop(&st);
StackPop(&st);
StackPop(&st);
StackDestroy(&st);
}
int main()
{
TestStack01();
}
二.队列
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)
入队列：进行插入操作的一端称为队尾
出队列：进行删除操作的一端称为队头
Queue.h 中部分声明
typedef int QDataType;
typedef struct QueueNode
{
QDataType data;
struct QueueNode* next;
}QueueNode;
typedef struct Queue
{
QueueNode* head;
QueueNode* tail;
}Queue;
(1).初始化队列
将队头和队尾指针置为空
void QueueInit(Queue* pq)
{
assert(pq);
pq->head = pq->tail = NULL;
}
(2).入队列
(1).若队列为空，使 head 和 tail 指针指向新申请的结点
(2).若队列不为空,使 tail->next 指向新申请的结点,并将 tail 移动到新的尾(tail = tail->next)
void QueuePush(Queue* pq, QDataType x)
{
assert(pq);
QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
if (newNode == NULL)
{
printf("malloc failed\n");
exit(-1);
}
newNode->data = x;
newNode->next = NULL;
if (pq->head == NULL)
{
pq->head = pq->tail = newNode;
}
else
{
pq->tail->next = newNode;
pq->tail = pq->tail->next;
}
}
(3).出队列
出队列相当于头删
(1).判断队列是否为空,为空断言报错
(2).保存住第二个结点的地址
(3).释放掉第一个结点
(4).改变 head 指针使其指向新的头
void QueuePop(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
QueueNode* next = pq->head->next;
free(pq->head);
pq->head = next;
}
(4).获取队列头部元素
(1).判断队列是否为空,为空断言报错
(2).返回 head->data
QDataType QueueFront(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->head->data;
}
(5).获取队列队尾元素
(1).判断队列是否为空,为空断言报错
(2).返回 tail->data
QDataType QueueBack(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->tail->data;
}
(6).获取队列中有效元素个数
遍历链表得到链表元素的个数即可
int QueueSize(Queue* pq)
{
assert(pq);
int count = 0;
QueueNode* cur = pq->head;
while (cur)
{
count++;
cur = cur->next;
}
return count;
}
(7).检测队列是否为空，如果为空返回true,非空为false
检测 head 指针是否为空即可
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->head == NULL;
}
(8). 销毁队列
遍历链表逐个销毁即可
void QueueDestroy(Queue* pq)
{
assert(pq);
QueueNode* cur = pq->head;
while (cur)
{
QueueNode* next = cur->next;
free(cur);
cur = next;
}
}
(9).完整代码实现
Queue.h
#pragma once
#includeQueue.c
#include"Queue.h"
// 队列初始化
void QueueInit(Queue* pq)
{
assert(pq);
pq->head = pq->tail = NULL;
}
// 入队
void QueuePush(Queue* pq, QDataType x)
{
assert(pq);
QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
if (newNode == NULL)
{
printf("malloc failed\n");
exit(-1);
}
newNode->data = x;
newNode->next = NULL;
if (pq->head == NULL)
{
pq->head = pq->tail = newNode;
}
else
{
pq->tail->next = newNode;
pq->tail = pq->tail->next;
}
}
// 出队
void QueuePop(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
QueueNode* next = pq->head->next;
free(pq->head);
pq->head = next;
}
// 判空
bool QueueEmpty(Queue* pq)
{
assert(pq);
return pq->head == NULL;
}
// 获取队尾元素
QDataType QueueBack(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->tail->data;
}
// 获取队头元素
QDataType QueueFront(Queue* pq)
{
assert(pq);
assert(!QueueEmpty(pq));
return pq->head->data;
}
// 销毁队列
void QueueDestroy(Queue* pq)
{
assert(pq);
QueueNode* cur = pq->head;
while (cur)
{
QueueNode* next = cur->next;
free(cur);
cur = next;
}
}
// 队列元素个数
int QueueSize(Queue* pq)
{
assert(pq);
int count = 0;
QueueNode* cur = pq->head;
while (cur)
{
count++;
cur = cur->next;
}
return count;
}