栈和队列的实现

栈和队列

栈

栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一段称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出的原则。

**压栈：**栈的插入操作叫做压栈，入数据在栈顶

**出栈：**栈的删除操作叫做出栈，出数据也在栈顶

我们可以把栈想象成一个桶，只能从桶口放东西进去，要想取出东西也只能从桶口里取出来。所以先放进去的会后取出来。如果想要拿到栈底的数据就必须把它前面的数据全部取出，才能取到栈底的数据。

栈的实现

栈的实现一般可以使用数组或链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。

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年的第一篇博客就结束啦，下次会拓展一些队列的知识。