数据结构入门——栈和队列详解

1 栈

1.1 栈的概念及结构

栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
对栈有两种操作：
插入操作：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。(本篇博客我们就叫入栈吧)
删除操作：栈的删除操作叫做出栈。出数据也在栈顶。（本篇博客我们叫出栈）

1.2 栈的实现

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

typedef int STDataType;
#define N 10
typedef struct Stack
{
 STDataType a[N];
 int top; // 栈顶
}Stack;

本图主要展示了由静态数组实现的栈，但是静态数组实现的栈并不实用，我们本篇博客主要实现的是支持动态增长的栈。

1.3 支持动态增长的栈

1.3.1 结构声明

// 支持动态增长的栈
#define DEFAULT_CAPACITY 4 //默认(初始)容量
typedef int STDataType;//栈存储的数据类型(这里为int)
typedef struct Stack
{
	STDataType* a;
	int top;		// 栈顶
	int capacity;  // 容量 
}Stack;

1.3.2 栈的初始化和销毁

函数声明：

// 初始化栈 
void StackInit(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);

函数实现：

void StackInit(Stack* ps)
{
	assert(ps);
	//先给数组开辟一个初始容量
	ps->a = (STDataType*)malloc(sizeof(STDataType) * DEFAULT_CAPACITY);
	if (ps->a == NULL)
	{
		perror("malloc failed");
		exit(-1);
	}
	ps->capacity = DEFAULT_CAPACITY;
	ps->top = -1;
}

void StackDestroy(Stack* ps)
{
	assert(ps);
	ps->capacity = 0;
	ps->top = -1;
	free(ps->a);
}

需要注意的点：我们的栈顶从top是-1开始的，用于保证栈顶元素的下标与top相同，但是栈的元素个数就是了top+1了。

1.3.3 入栈和出栈操作

函数声明：

// 入栈 
void StackPush(Stack* ps, STDataType data);
// 出栈 
void StackPop(Stack* ps);
// 获取栈顶元素 
STDataType StackTop(Stack* ps);

函数实现：

void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	//入栈之前先检查，栈是否满了，满了就需要扩容后再入栈
	if (ps->top + 1 == ps->capacity)
	{
		STDataType* tmp = realloc(ps->a, sizeof(STDataType) * (ps->capacity) * 2);
		if (tmp == NULL)
		{
			perror("realloc failed");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}
	(ps->top)++;
	ps->a[ps->top] = data;
}

void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->top != -1);
	(ps->top)--;
}

STDataType StackTop(Stack* ps)
{
	assert(ps);
	return ps->a[ps->top];
}

需要注意的是，我们这里的出栈函数分成了两个来写，一个只删除栈顶元素，一个只获取栈顶元素。这里写成一个函数也是可以的，即出栈函数，删除栈顶元素并返回该栈顶元素。

1.3.4 栈的判空和元素个数

函数声明：

// 获取栈中有效元素个数 
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回true，如果不为空返回false
bool StackEmpty(Stack* ps);

函数实现:

// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top + 1;
}
// 检测栈是否为空
bool StackEmpty(Stack* ps)
{
	assert(ps);
	return (ps->top == -1);
}

2 队列

2.1 队列的概念及结构

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

2.2 队列的实现

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

2.3 链表实现队列

2.3.1 结构声明

//队列声明
typedef int QNodeDataType;
typedef struct QNode
{
	QNodeDataType x;
	struct QNode* next;
}QNode;
typedef struct Queue
{
	QNode* head;//头指针
	QNode* tail;//尾指针
	size_t size;
}Queue;

2.3.2 队列的初始化和销毁

函数声明

// 初始化队列 
void QueueInit(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);

函数实现：

// 初始化队列 
void QueueInit(Queue* q)
{
	assert(q);
	q->head = q->tail = NULL;
	q->size = 0;
}

// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->head;
	while (cur)
	{
		QNode* tmp = cur;
		cur = cur->next;
		free(tmp);
	}
	q->head = q->tail = NULL;
	q->size = 0;
}

2.3.3 队列入队和出队

函数声明：

// 队尾入队列 
void QueuePush(Queue* q, QNodeDataType data);
// 队头出队列 
void QueuePop(Queue* q);
// 获取队列头部元素 
QNodeDataType QueueFront(Queue* q);
// 获取队列队尾元素 
QNodeDataType QueueBack(Queue* q);

函数实现：

// 队尾入队列 
void QueuePush(Queue* q, QNodeDataType data)
{
	assert(q);
	QNode* newNode = (QNode*)malloc(sizeof(QNode));
	if (newNode == NULL)
	{
		perror("malloc failed");
		exit(-1);
	}
	newNode->next = NULL;
	newNode->x = data;
	if (q->tail == NULL)
	{
		q->head = q->tail = newNode;
	}
	else
	{
		q->tail->next = newNode;
		q->tail = q->tail->next;
	}
	q->size++;
}
// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	if (q->head->next == NULL)
	{
		free(q->head);
		q->head = q->tail = NULL;
	}
	else
	{
		QNode* tmp = q->head;
		q->head = q->head->next;
		free(tmp);
	}
	q->size--;
}
// 获取队列头部元素 
QNodeDataType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->head->x;
}
// 获取队列队尾元素 
QNodeDataType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->tail->x;
}

同理，这里的功能也是分开写的，也可以合并起来写。

2.3.4 队列判空和获取元素个数

函数声明：

// 获取队列中有效元素个数 
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回true，如果非空返回false
bool QueueEmpty(Queue* q);

函数实现：

// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);
	return q->size;
}
// 检测队列是否为空
bool QueueEmpty(Queue* q)
{
	assert(q);
	return (q->size == 0);
}

总结

栈和队列是相对比较简单的两个结构了，他们多用于其他复杂结构的子结构(后期会讲到)。下一期会介绍几道它们的例题。
聊一下与本篇博客无关的内容，其实可以看到我停更了比较长的一段时间，主要原因是临近期末，复习去了，而且博主并不是计算机专业的，是自动化专业的，刚好这学期的课程比较多，所以复习内容也比较多，所以停更了比较长的时间，希望大家理解。这几天刚刚放假，会速度更新的。