栈和队列回顾

目录

栈

栈的定义和概念

栈的基本实现

栈的初始化

栈的销毁

栈的打印

入栈

出栈

查找栈顶元素

栈的判空

队列

队列的定义与概念

栈的基本实现

队列的初始化

队列的销毁

入队列

出队列

队列判空

获取队列头

获取队列尾

获取队列元素多少

---

栈

栈的定义和概念

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端 称为栈顶，另一端称为栈底。

栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。

由于栈后进先出的特点，存储栈的数据结构用数组更为简单 

栈的基本实现

头文件

#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>

typedef int STDataType;
typedef struct Stack {
	STDataType* arr;
	int top;
	int capacity;
}ST;

//栈的初始化
void STInit(ST* pst);

//栈的销毁
void STDestroy(ST* pst);

//打印栈
void STPrint(ST* pst);

//入栈
void STPush(ST* pst, STDataType x);

//出栈
void STPop(ST* pst);

//查找栈顶元素
STDataType STFind(ST* pst);

//栈的判空
bool STEmpty(ST* pst);

//获取栈中数据数量
int STSize(ST* pst);

实现代码

栈的初始化

先让指向pst中arr的指针为空，栈元素个数与空间为0。让top位于数据的后1位，则top下标减第一个下表值即为栈的大小

//栈的初始化
void STInit(ST* pst)
{
	assert(pst);
	pst->arr = NULL;
	pst->top = 0;
	pst->capacity = 0;
}

栈的销毁

先释放掉指向数组的指针，再让其指向空，然后让top与capacity置为0

//栈的销毁
void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->arr);
	pst->arr = NULL;
	pst->top = pst->capacity = 0;
}

栈的打印

//打印栈
void STPrint(ST* pst)
{
	int i;
	for (i = 0; i < pst->top; i++) {
		printf("%d ", pst->arr[i]);
	}
	printf("\n");
}

入栈

入栈前先检查栈是否有足够的空间，若top == capacity则表明栈满了，需要扩容。为了避免大量的空间浪费，若原空间为0，就先开4个STDataType大小的空间（STDataType在此处为int类型，在头文件处已声明）；若原空间不为0，则开够原空间的2倍。

空间开辟完成后，把需要入栈的数据直接插在pst->arr[pst->top]处，然后让pst->top++

//入栈
void STPush(ST* pst, STDataType x)
{
	assert(pst);
	//扩容
	STDataType* tmp;
	if (pst->top == pst->capacity) {
		int newcapacity = pst->capacity == 0 ? 4 : 2 * pst->capacity;
		tmp = (STDataType*)realloc(pst->arr, newcapacity * sizeof(STDataType));
		if (tmp == NULL) {
			perror("realloc fail\n");
		}
		pst->arr = tmp;
		pst->capacity = newcapacity;
	}
	
	pst->arr[pst->top] = x;
	pst->top++;
}

出栈

直接把栈顶数据删除即可

//出栈
void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	pst->top--;
}

查找栈顶元素

直接返回栈顶元素即可

//查找栈顶元素
STDataType STFind(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	return pst->arr[pst->top - 1];
}

栈的判空

如果pst->top为0，则栈为空，否则不然。

//栈的判空
bool STEmpty(ST* pst)
{
	assert(pst);
	return pst->top == 0;
}

获取栈中数据数量

//获取栈中数据数量
int STSize(ST* pst)
{
	assert(pst);
	return pst->top;
}

队列

队列的定义与概念

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头

由于队列涉及两头操作，用数组就不方便了，所以存储队列的数据结构用链表会方便些，而用双向链表又显得多余，因此单链表足矣。

栈的基本实现

头文件

#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int QDataType;
typedef struct QueueNode {
	QDataType val;
	struct QueueNode* next;
}QNode;

typedef struct Queue {
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;

//队列的初始化
void QuInit(Queue* pq);
//队列的销毁
void QuDestroy(Queue* pq);

//入队列
void QuPush(Queue* pq, QDataType x);
//出队列
void QuPop(Queue* pq);

//队列判空
bool QuEmpty(Queue* pq);

//获取队列头
QDataType QuGetHead(Queue* pq);
//获取队列尾
QDataType QuGetTail(Queue* pq);

//获取队列大小
int QuSize(Queue* pq);

这里定义一个QueueNode的结构体，里面包含存储的值val和指向下一个节点的指针next，并将该结构体命名为QNode。另外为了方便队列的其他操作，经常要获取链表的头节点和尾节点未免过于耗时，因此定义一个Queue的结构体，用于存放链表的头节点、尾节点和链表数据个数，并命名为Queue。

实现代码

队列的初始化

//队列的初始化
void QuInit(Queue* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

队列的销毁

//队列的销毁
void QuDestroy(Queue* pq)
{
	assert(pq);
	assert(pq->phead != NULL);
	QNode* cur = pq->phead;
	while (cur) {
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

入队列

入队列前先开辟节点空间，如果此时的队列是空队列，则直接把新开辟的节点给给头节点和尾节点。如果不为空，则让尾节点的net指针指向新开辟的节点，然后让新开辟的节点成为新的尾节点。最后增加链表元素个数。

//入队列
void QuPush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL) {
		perror("newnode malloc fail\n");
		return;
	}
	newnode->next = NULL;
	newnode->val = x;
	
	//空队列
	if (pq->phead == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else 
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}

出队列

出队列先判断队列里还是否有节点，然后分两种情况出。一种是只剩最后一个节点，那么先free掉头节点，然后让头尾节点指向空，并让size--。另一种是还剩不止一个节点，那么就先存下头节点的下一个节点，然后再free掉头节点，并让存下的节点成为新的头节点，最后size--。

//出队列
void QuPop(Queue* pq)
{
	assert(pq);
	assert(pq->size != 0);
	if (pq->phead->next == NULL) {
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
		pq->size--;
	}
	else {
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
		pq->size--;
	}
}

队列判空

//队列判空
bool QuEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}

获取队列头

//获取队列头
QDataType QuGetHead(Queue* pq)
{
	assert(pq);
	assert(pq->phead != NULL);
	return pq->phead->val;
}

获取队列尾

//获取队列尾
QDataType QuGetTail(Queue* pq)
{
	assert(pq);
	assert(pq->ptail != NULL);
	return pq->ptail->val;
}

获取队列元素多少

//获取队列大小
int QuSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}