栈和队列基础知识和实现

1. 栈

1.1 栈的概念及其结构

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

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

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

1.2 栈的实现

栈一般可以通过数组或者链表来实现。相较来说，数组实现更好一点，因为数组在尾部插入数据的时候消耗更小。

栈的定义

首先我们需要定义一个结构体并将其命名为栈，我们需要从栈顶插入元素并且还要知道该栈的容积以方便后面空间不够完成扩容（如果我们一次开辟较多的空间就浪费了）。

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}Stack;

栈的初始化

我们需要开辟一个空间来存储数据，因此我们需要在堆上malloc一个数组。

void StackInit(Stack* ps)
{
	assert(ps);
	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		perror("malloc fail\n");
		return;
	}
	ps->top = 0;
	ps->capacity = 4;
}

数据入栈

我们将数据插入栈就是直接在数组的最后加入数据，那么我们就需要判断数组是否需要扩容。然后再插入数据到数组中。

void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		STDataType* temp = (STDataType*)realloc(ps->a, sizeof(STDataType) * ps->capacity * 2);
		if (temp == NULL)
		{
			perror("realloc fail\n");
			return;
		}
		ps->a = temp;
		ps->capacity *= 2;
	}
	ps->a[ps->top] = data;
	ps->top++;
}

数据出栈

判断栈是否为空，如果为空就不能出栈，如果不为空直接让top--即可。（处于数组中的数据实际上我们并没有处理）

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

查看栈顶元素

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

查看栈的大小

因为我们的top定义为0，每次插入数据后top++，因此top的大小就是数组的存储数据的多少。

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}

判断栈是否为空

bool StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top == 0;
}

栈的销毁

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

2. 队列

2.1 队列的概念及其结构

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

队头：数据删除的一端，又称队首。

队尾：数据插入的一段

2.2 队列的实现

队列的定义

我们需要定义一个结构体QueueNode来让一个队列元素链接到下一个队列元素。同时我们定义一个Queue来包含一个队头和队尾来方便我们插入和删除。

typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

队列的初始化

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}

入队列

如果队列为空，那么我们需要对head和tail都修改，如果不为空那么修改tail即可，并且让size++。

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->head == NULL)
	{
		assert(pq->tail == NULL);
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = pq->tail->next;
	}
	pq->size++;
}

出队列

如果队列只有一个元素那么直接释放即可，并且置空head和tail；如果不止一个元素那么就释放最后一个元素并且让前一个元素的next置空即可。最后size--。

void QueuePop(Queue* pq)
{
	assert(pq);
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* del = pq->head;
		pq->head = pq->head->next;
		free(del);
		del = NULL;
	}
	pq->size--;
}

队头元素查看

因为我们设置了一个head，那么我们直接查看head->data即可。

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->head->data;
}

队尾元素查看

因为我们设置了一个tail，那么我们直接查看tail->data即可。

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}

队列的大小

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

队列是否为空

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

队列的销毁

像链表一样使用一个cur指针从head开始知道其为NULL，逐步释放。

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->size = 0;
	pq->head = pq->tail = NULL;
}