数据结构————栈和队列

本章讲解，数据结构里面的栈和队列。

什么是栈

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

压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。

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

结构示意图：

栈的实现

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

下面，我们就用数组来实现一下栈。

首先，对于栈的结构体定义一般是这样的：

typedef int StackDataType;
typedef struct stack
{
	StackDataType* a;
	int top;
	int capacity;
}ST;

定义一个指针 a：指向要开辟出来的一块数组空间，用来存放栈中的元素。

定义一个top：指向栈顶的下一个。

定义一个capacity：记录栈的空间大小。

结构示意图：

对于栈，我们主要实现以下几种功能：

• 初始化栈
• 入栈
• 出栈
• 获取栈顶元素
• 获取栈中有效元素个数
• 检测栈是否为空
• 销毁栈

初始化栈

按照之前的逻辑，top指向栈顶的下一个，所以初始化成 0 值。毕竟一开始是没有元素的。

void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->top = 0;
	pst->capacity = 0;
}

入栈

首先，肯定是判断容量是不是满的，不满再入栈，满的话，要先进行扩容后，再入栈。

通过前面的结构图，可以发现，top不仅是栈顶下一个元素的下标，根据数组的性质，同时也是数组元素的个数（栈顶元素的有效个数）。

所以capacity 等于top，就是满。

void STPush(ST* pst, StackDataType x)
{

	//1.判断扩容
	if (pst->capacity == pst->top)
	{
		int newcapacity = 0 == pst->capacity ? 4 : pst->capacity * 2;//容量为空：开辟4个空间；不为空：开辟2倍。
		StackDataType* tmp = (StackDataType*)realloc(pst->a,newcapacity * sizeof(StackDataType));
		if (tmp == NULL)
		{
			perror("realloc fail:");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	}

	pst->a[pst->top] = x;
	pst->top++;
}

出栈

由于是数组实现的，直接top-- 。

void STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));

	pst->top--;
}

获取栈顶元素

栈顶元素的下标：top-1

StackDataType STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));

	return pst->a[pst->top-1];
}

获取栈中有效元素个数

int STSize(ST* pst)
{
	assert(pst);

	return pst->top;
}

检测栈是否为空

bool STEmpty(ST* pst)
{
	assert(pst);
	return pst->top == 0;
}

销毁栈

销毁时要注意：将结构体内部的a指针指向的数组空间销毁

void STDestory(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->capacity = 0;
	pst->top = 0;
}

队列

队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出

FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾

出队列：进行删除操作的一端称为队头

结构示意图：

 

队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

现在，我们用链表来实现一个队列。

首先，对于结构体的定义是这样的：

如图：

 为了方便实现队列的先进先出，在队列结构体中加入，一个指向同头节点的指针，一个指向尾节点的指针。

// 队列的结构 
typedef struct Queue
{
	QNode* front;
	QNode* rear;
	int size;
}Queue;

size表示：有效元素的个数。（因为是链表实现，为方便统计增加一个size）

每个链表的节点，我们采用单向链表的形式。

typedef int QDataType;

typedef struct QListNode
{
	struct QListNode* next;
	QDataType data;
}QNode;

下面，对于队列，我们主要实现以下几种功能：

• // 初始化队列 
• void QueueInit(Queue* q);
• // 队尾入队列 
• void QueuePush(Queue* q, QDataType data);
• // 队头出队列 
• void QueuePop(Queue* q);
• // 获取队列头部元素 
• QDataType QueueFront(Queue* q);
• // 获取队列队尾元素 
• QDataType QueueBack(Queue* q);
• // 获取队列中有效元素个数 
• int QueueSize(Queue* q);
• // 检测队列是否为空
• bool QueueEmpty(Queue* q);
• // 销毁队列 
• void QueueDestroy(Queue* q);

初始化队列 

void QueueInit(Queue* q)
{
	assert(q);
	q->front = NULL;
	q->rear = NULL;
	q->size = 0;
}

队尾入队列

因为是单向链表，所以在入队列时要注意区分有节点和无节点的情况。

void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail:");
		return;
	}
	newnode->next = NULL;
	newnode->data = data;
	if (q->front == NULL)
	{
		assert(q->rear == NULL);
		q->front = q->rear = newnode;
	}
	else
	{
		q->rear->next = newnode;
		q->rear = newnode;
	}
	q->size++;
}

队头出队列 

出队列要注意：一个节点和多个节点的区别。

void QueuePop(Queue* q)
{
	assert(q);
	assert(q->front);
	//1.一个节点
	//2.多个节点
	if (q->front == q->rear)
	{
		QNode* phead = q->front;
		q->front = q->rear = NULL;
		free(phead);
	}
	else
	{
		QNode* phead = q->front;
		q->front = q->front->next;
		free(phead);
	}
	q->size--;
}

获取队列头部元素 

QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(q->front);
	return q->front->data;
}

获取队列队尾元素 

QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(q->rear);
	return q->rear->data;
}

获取队列中有效元素个数

int QueueSize(Queue* q)
{
	assert(q);
	return q->size;
}

检测队列是否为空

bool QueueEmpty(Queue* q)
{
	assert(q);
	return q->size == 0;
}

销毁队列 

对链表进行遍历，找到每个节点并销毁。

void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->front;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	q->front = q->rear = NULL;
	q->size = 0;
}

感谢语

感谢大家的观看，若有不足之处，欢迎指点。