用C语言创建基本的栈与队列

一：栈

1.什么是栈？

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

2.数组栈与链式栈哪个更优？

• 如果利用链式结构实现栈，因为栈遵循后入先出，我们需要在栈顶进行插入和删除操作，如果把单链表的尾作为栈顶，插入方便，但是不利于删除，要设计成双向链表
• 如果把单链表的头作为栈顶，头插头删比较方便，利于实现栈，但由于在内存中不是顺序存储，CPU缓存利用率较低。
• 如果利用数组结构实现栈，将数组最后一个位置当做栈顶，进行插入删除操作同样方便，并且不需要多存储一个指针，由于是顺序存储，CPU缓存利用率更高，缺点是需要增容，会有一定的消耗。
• 综上，利用数组或者链式结构实现栈均可，各有优缺点，我下面讲述实现栈的方式利用的数组结构。

3.栈的实现

Stack.h

• 利用数组实现栈，我们除了需要数组以外还需要两个变量
• 一个是top，指向的是栈顶，方便进行插入和删除操作，一个是capacity，存储目前数组的大小，空间不够时需要扩容，将它们三个装进一个结构体中，我们的栈的框架就搭建好了。
• 剩下我们需要对栈进行初始化，删除，插入，查询栈顶元素，查询大小，查询是否为空，销毁这些操作，将对应的函数都在头文件中进行初始化。
• 剩下的工作就是实现对应的函数了。

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

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;
void StackInit(ST* ps);
void StackPop(ST* ps);
void StackPush(ST* ps, STDataType x);
void StackDestroy(ST* ps);
STDataType StackTop(ST* ps);
int StackSize(ST* ps);
bool StackEmpty(ST* ps);

Stack.c

<1> StackInit

• 每一个函数首先都需要对参数ps进行判断，它代表的是栈的地址，不可能为空（除非参数传错），使用断言的方式如果我们传了NULL还能报错提醒我们，十分地合适。
• 接下来就是简单的初始化，将a置为NULL，将top和capacity置为0

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

<2> StackPop

• 删除的操作需要判断栈是否为空，可以直接调用StackEmpty函数
• 接下来只要将top自减一就足够了，保证我们找不到它，不用真的删除

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

<3> StackPush

• 进行插入之前需要对数组大小进行判断，如果数组容量不够，即top==capycity时需要进行扩容。
• 扩容成功后将数组的top位置数据改为传入的参数x，再将top++，指向下一个待插入元素的位置，注意top不指向最后一个元素。

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int NewCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType *)realloc(ps->a, sizeof(STDataType) * NewCapacity);
		if (tmp == NULL)
		{
			perror("realloc");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = NewCapacity;
	}

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

<4> StackDestroy

• 销毁链表十分的简单，只需要先释放a，再让a指向NULL，top和capacity置为0即可
• 其实好像和初始化没区别

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

<5> StackTop

• 这个函数是用于查询栈顶元素并返回栈顶元素的值，所以栈为空就不用查询了，查了也是一个随机值，故先对栈不为空进行断言。
• 之后返回的位置需要注意，是返回a[top-1],不是top，因为top指向的是最后一个元素的下一个位置。

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

<6> StackSize

• top的大小其实就是栈的大小

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

<7> StackEmpty

• 只要top为0，栈就为空，其它时候都不为空
• 所以可以直接返回表达式ps->top == 0，如果成立证明栈为空返回的为Ture，否则返回False

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

<8> 测试效果

• 可以看到先入压栈压入1和2，之后出栈，再让3、4入栈，之后再将剩余元素出栈
• 因为2在1后入栈，根据后入先出，2先出栈，3,4同样如此，最终2先出栈，然后出4、3，最终1才出栈。
  

二：队列

1.什么是队列？

• 队列，同样是一种特殊的线性表，它只允许在一端进行插入数据的操作，在另一端进行删除数据的操作进行数据插入一端称为队尾，进行数据删除的一端称为队头。
• 遵循先进先出（First In First Out）的原则。
  

2.数组队列与链式队列哪个更优？

• 如果利用链式结构实现队列，将头节点当做队头，链尾当做队尾，进行头删十分方便，但单链表的尾插需要遍历链表，时间复杂度为O(N),为了避免每次都寻找链表的尾部，可以在一开始就定义一个尾指针指向尾部，每次插入以后改变尾指针的位置，就可以避免频繁查找。
• 如果利用数组结构实现队列，将数组最后一个位置为队尾，数组第一个位置为队头，在尾部插入操作很方便，但需要在头部进行删除操作，这需要对数组进行遍历，时间复杂度为O（N），效率低。
• 综上，利用链式结构实现队列效率更高。

3.队列的实现

Queue.h

• 利用单链表实现队列，上文提及，除了需要头指针以外，还需要尾指针便于尾插。
• 将链表的每个节点，指针域和数据域封装进一个结构体，将头指针和尾指针装入另一个结构体，避免对每个函数都需要多传头指针和尾指针两个参数。
• 剩下我们需要对队列进行初始化，删除，插入，查询队头队尾元素，查询大小，查询是否为空，销毁这些操作，将对应的函数都在头文件中进行初始化。
• 剩下的工作就是实现对应的函数了。

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

typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;

}QueueNode;
typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;

}Queue;
void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
int QueueSize(Queue* pq);
bool QueueEmpty(Queue* pq);

Queue.c

<1> QueueInit

• 每一个函数首先都需要对参数pq进行判断，它代表的是队列的地址，不可能为空（除非参数传错），使用断言的方式如果我们传了NULL还能报错提醒我们，十分地合适。
• 由于队列一开始没有节点，故头尾节点均指向NULL

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

<2> QueueDestroy

• 销毁队列时需要注意，不能直接free(pq->head)
• 需要对每个节点都进行free,之后将头尾节点都置为NULL。

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

<3> QueuePush

• 插入元素时首先申请一个新的节点，之后判断队列是不是空，如果是空将头尾指针同时指向新节点就插入完成
• 如果队列不为空，将尾指针的next指向NewNode,之后再移动尾指针的位置指向新的尾

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QueueNode* NewNode = (QueueNode*)malloc(sizeof(QueueNode));
	NewNode->next = NULL;
	NewNode->data = x;
	if (pq->head == NULL)
	{
		pq->head = pq->tail = NewNode;
	}
	else
	{
		pq->tail->next = NewNode;
		pq->tail = NewNode;
	}
}

<4> QueuePop

• 删除队列元素需要对队列是否为空进行判断，为空就不能继续删除了，可以直接调用QueueEmpty函数。
• 之后新建变量next指向头结点的下一节点，再释放头结点，将头指针指向新的头节点，就删除成功了
• 还有一个细节需要注意，我们一直没有动尾指针，但是这样当队列为空时尾指针就会变成野指针，所以当队列为空即头指针为空时，代表已经删除了最后一个元素时，我们需要将尾指针也置为NULL

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	QueueNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}
}

<5> QueueFront

• 不为空就返回头节点的值

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

<6> QueueBack

• 不为空就返回尾节点的值

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

<7> QueueSize

• 从头节点开始遍历队列计算元素个数，cur为NULL时停止

int QueueSize(Queue* pq)
{
	int n=0;
	QueueNode* cur = pq->head;
	while (cur)
	{
		n++;
		cur = cur->next;
	}
	return n;
}

<8> QueueEmpty

• 如果头指针为NULL代表队列为空，否则队列不为空
• 故可以直接返回pq->head == NULL，如果表达式为真，代表头指针为NULL，返回True,代表队列为空，否则返回False

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}

<9> 测试效果

• 如图，先插入1,2，然后出队列，再插入3,4，再出声音队列
• 最终结果为1,2,3,4，可见无论什么时候出队列都遵循先入先出的规则