栈和队列
栈
栈是一种特殊的线性表,其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一段称为栈顶,另一端称为栈底。栈中的数据元素遵守后进先出的原则。
**压栈:**栈的插入操作叫做压栈,入数据在栈顶
**出栈:**栈的删除操作叫做出栈,出数据也在栈顶
我们可以把栈想象成一个桶,只能从桶口放东西进去,要想取出东西也只能从桶口里取出来。所以先放进去的会后取出来。如果想要拿到栈底的数据就必须把它前面的数据全部取出,才能取到栈底的数据。
栈的实现
栈的实现一般可以使用数组或链表实现,相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。
typedef int StackDataType;
// 栈适合用顺序表实现,先进后出
typedef struct stack {
StackDataType* arr;
int top;
int capacity;
}ST;
// 初始化栈
void StackInit(ST* sk);
// 向栈中放入数据
void StackPush(ST* sk, StackDataType x);
// 显示栈
void StackShow(ST* sk);
// 删除栈的数据
void StackPop(ST* sk);
// 获取栈顶数据
StackDataType StackTop(ST* sk);
// 销毁栈
void StackDestroy(ST* sk);
在完成栈的时候,我是定义了一个结构体,这个结构体有三个成员变量。第一个是可以边长的数组arr
,第二个是栈顶指针top
,第三个是栈的容量capacity
。
当我们定义好了栈的结构之后,就要使用栈,定义栈的变量然后初始化栈,之后就进行入栈出栈的操作。
// 初始化的过程就是将结构体的成员变量给上初始值,给数组分配空间。
// 初始化栈
void StackInit(ST* sk)
assert(sk);
sk->arr = (StackDataType*)malloc(sizeof(StackDataType) * STACKSIZE);
sk->top = 0;
sk->capacity = STACKSIZE;
}
初始化完之后就可以对数组进行入栈和出栈的操作,所以接下来实现入栈和出栈的操作
// 入栈操作
// 向栈中放入数据
void StackPush(ST* sk, StackDataType x) {
assert(sk);
if (sk->top >= sk->capacity) {
StackDataType* tmp = (StackDataType*)realloc(sk->arr, sizeof(StackDataType) * sk->capacity * 2);
sk->arr = tmp;
sk->capacity *= 2;
}
sk->arr[sk->top] = x;
sk->top++;
}
入栈就是将数据尾插到数组中,入栈涉及到一个数组扩容的问题,也就是说当我们插入数据的数量大于栈的容量时,就要对数组进行扩容。所以在入栈操作时需要对数组进行判断,看看数组是否已经满了,满了就扩容,然后再插入。
// 出栈操作
// 删除栈的数据
void StackPop(ST* sk) {
assert(sk);
assert(sk->top > 0);// 判断数组是否为空,为空就会报异常
sk->top--;
}
出栈操作就是将栈顶的数据删除,由入栈操作的代码我们可以知道,数组中最后一个有效数据就是栈顶元素,所以出栈操作可以看作是将数组的元素进行尾删操作。
// 获取栈顶元素
// 获取栈顶数据
StackDataType StackTop(ST* sk) {
assert(sk);
assert(sk->top > 0);
return sk->arr[sk->top-1];
}
获取栈顶元素就是将获取数组的最后一个数据
// 显示栈
void StackShow(ST* sk) {
assert(sk);
int i = 0;
for (i = 0; i < sk->top; i++) {
printf("%d|", sk->arr[i]);
}
}
// 这个函数的作用就是将栈遍历一遍,然后打印出来
当我们使用完栈之后就要将申请的空间释放掉,所以需要销毁栈
// 销毁栈
void StackDestroy(ST* sk) {
assert(sk);
free(sk->arr);
sk->top = sk->capacity = 0;
}
队列
队列只允许在一端进行数据操作,在另一端进行删除数据操作的特殊线性表,队列具有先进先出的特点,进行插入操作的一端称为队尾,进行删除操作的一段称为队头。
队列的实现
队列可以用数组实现也可以用链表实现,使用链表的结构实现更优一些,因为如果使用数组的结构,出队列在数组头上的数据,效率会比较低。因为,如果用数组实现的话,每出队列一个数据就要把数组中剩下的所有数据都往前面挪动,而使用链表实现的话就不会存在这样的问题。
typedef int QueDataType;
//定义一个队列的结点
typedef struct QueNode {
QueDataType data;
struct QueNode* next;
}QNode;
// 定义一个队列的结构
typedef struct Queue {
QNode* qhead;
QNode* top;
QNode* tail;
}Que;
// 初始化队列
void QueueInit(Que* qu);
//显示队列中的数据
void QueShow(Que* qu);
// 向队列中添加数据
void QuePush(Que* qu, QueDataType x);
// 出队列
void QuePop(Que* qu);
// 显示队头数据
QueDataType QueueFront(Que* qu);
// 获取队列队尾元素
QueDataType QueueBack(Que* qu);
// 获取队列中有效元素个数
int QueueSize(Que* qu);
// 销毁队列
void QueueDestroy(Que* qu);
因为我们需要用链表来实现队列,所以就需要定义节点的结构体,节点包含数据data
部分和下一个节点的指针next
部分。这是节点,而队列则是由三个成员变量组成,第一个是用来存放数据的节点qhead
,第二个就是指向队头的指针top
,第三个就是指向队尾的指针tail
。
定义好节点和队列结构体之后就需要完成对队列的操作,首先是初始化队列,初始化队列就是给队列的成员赋上初始值。
// 初始化队列
void QueueInit(Que* qu) {
qu->qhead = NULL;
qu->top = qu->tail = NULL;
}
把队列初始化之后,就可以对队列进行入队列和出队列的操作
// 入队列
// 向队列中添加数据
void QuePush(Que* qu, QueDataType x) {
assert(qu);
QNode* newnode = (QNode*)malloc(sizeof(QNode)); // 创建一个新节点
if (newnode == NULL) {
return;
}
newnode->data = x;
newnode->next = NULL;
if (qu->qhead == NULL) { // 如果队列是空的就将新节点放到队头
qu->qhead = newnode;
qu->tail = qu->qhead;// tail指向链表中的最后一个元素
qu->top = qu->qhead;
}
else {
qu->tail->next = newnode; // 如果队列不为空,就将数据插入到tail的后一个位置
qu->tail = qu->tail->next;
}
}
出队列,就很简单,就是释放掉top指向的那个节点首先让phead
指向top的后一个节点,然后再释放掉top指向的节点即可。
// 出队列
void QuePop(Que* qu) {
assert(qu);
assert(qu->qhead);
qu->qhead = qu->top->next; // 先让phead指向
free(qu->top);
qu->top = qu->qhead;
}
完成了出入队列后,或许我们希望看看队列里的数据到底有哪些,那么我们就可以写一个打印队列的函数,遍历队列,然后把队列中的数据打印出来。
//显示队列中的数据
void QueShow(Que* qu) {
assert(qu);
QNode* tail = qu->qhead;
while (tail) {
printf("%d | ", tail->data);
tail = tail->next;
}
}
有时我们需要先获取到对头的数据再将它出队列
// 获取队头数据
QueDataType QueueFront(Que* qu) {
assert(qu);
assert(qu->qhead);
return qu->top->data;
}
查看队列中的有效元素的个数,这里采用的是累加法,也就是说通过遍历队列,没遇到NULL就加一,以此来获取队列中有效元素的个数。
// 获取队列中有效元素个数
int QueueSize(Que* qu) {
assert(qu);
assert(qu->qhead);
int count = 0;
QNode* tmp = qu->top;
while (NULL != tmp) {
count++;
tmp = tmp->next;
}
return count;
}
和栈一样的,我们在使用完队列后需要将申请的空间释放掉,就需要销毁队列
// 销毁队列
void QueueDestroy(Que* qu) {
assert(qu);
assert(qu->qhead);
QNode* ftmp = qu->qhead;
while (ftmp) {
QNode* tmp = ftmp;
ftmp = ftmp->next;
free(tmp);
}
qu->tail = NULL;
qu->top = NULL;
qu = NULL;
}
2022年的第一篇博客就结束啦,下次会拓展一些队列的知识。