数据结构：栈和队列

       栈和队列也就是前面顺序表和链表的延续，代码实现难度并不高。

一、栈

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

       它就好比：

       或者：

       不管是一串烤串，或者一桶羽毛球，最后一个进去的一块肉或者羽毛球总是被最先拿出来，它们可以很形象的形容栈是什么样的数据结构。

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

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

二、栈的实现

       下面我们就基于数组来实现栈。

       首先实现出来栈的基本结构：

//定义栈的基础结构
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;

       它包含了一个存储着元素的空间地址的指针变量成员，一个做为数组下标的整型变量成员top，一个表示栈的容量的整形变量成员capacity。

       一般实现一个栈需要实现一下几个基本函数。

//初始化
void STInit(ST* ps);

//销毁
void STDestory(ST* ps);

//入栈
void STPush(ST* ps, STDataType  x);
//出栈
void STPop(ST* ps);

//取栈顶元素
STDataType STTop(ST* ps);

//统计栈中元素个数
int STSize(ST* ps);
bool STEmpty(ST* ps);

1.栈的初始化

//初始化
void STInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

2.入栈

//插入元素
void STPush(ST* ps, STDataType  x)
{
	assert(ps);
	if (ps->top == ps->capacity)//数组的下标等于栈的容量，那么就代表着栈已经满了，需要扩容。
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//是一个三目表达式，将表达式的结果赋给变量newcapacity
		//如果刚开始栈为空，容量为0，那么就给栈扩容四个元素的空间，随后便以二倍数增长的形式扩容。
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));//用realloc扩容。
		if (tmp == NULL)//判断一下扩容是否成功。
		{
			perror("realloc fail");
			return;
		}
		ps->a = tmp;
		ps->capacity = newcapacity;//扩容成功，就将新开辟的空间给到栈里面。
	}
	ps->a[ps->top] = x;//将元素插入到栈里面。
	ps->top++;
}

       入栈的操作就相当于顺序表的尾插。

3.判断栈是否为空

//判断栈是否为空
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;//使用一个表达式的结果做为返回值
}

4.出栈

//删除元素
void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));//删除元素时栈里面元素不能为空
	ps->top--;
}

       出栈的操作非常简单，只需将下标减1即可。

5.取栈顶元素

//取栈顶元素
STDataType STTop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	return ps->a[ps->top-1];
}

       取栈顶元素指的是将栈顶元素作为返回值返回出去。

6.统计栈中元素个数

//统计栈中元素个数
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

       实现这个函数也非常的简单，直接将元素下标作为返回值返回出去。

7.栈的销毁

//销毁
void STDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

       free函数的作用是将a指向的空间释放。

       至此我们就将栈给实现完毕了。

三、队列

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

       入队列：进行插入操作的一端称为队尾。

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

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

四、队列的实现

       队列的基本结构：

//定义并命名为QNode
typedef struct QueueNode
{
	int val;
	struct QueueNode* next;
}QNode;

typedef struct Queue
{
	QNode* phead;//指向队头的指针
	QNode* ptail;//指向队尾
	int size;//表示队列的元素个数
}Queue;//将上述指针等成员封装成一个结构体变量

       它有两个成员：一个存储着元素的变量val，一个指向下一个节点结构体指针。

       当我们有多个指针的时候，一个一个指针地传比较麻烦，我们可以将它们装在一个结构体里面，这样想要穿指针的时候直接传结构体即可。这种方式会更加方便。

       一般实现一个队列需要实现以下函数：

//初始化
void QueueInit(Queue* pq);

//销毁
void QueueDestory(Queue* pq);

//入队列
void QueuePush(Queue* pq, QDataType x);

//出队列
void QueuePop(Queue* pq);

//取队头
QDataType QueueFront(Queue* pq);

//取队尾
QDataType QueueBack(Queue* pq);

//判断队列是否为空
bool QueueEmpty(Queue* pq);

//统计队列中元素的个数
int QueueSize(Queue* pq);

1.队列初始化

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

2.入队列

//入队列
void QueuePush(Queue* pq,QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->val = x;
	newnode->next = NULL;//现申请一块新空间存放新节点并将新的数据赋给新节点。
	if (pq->ptail)//如果队列不为空，那么就将ptail的下一个节点作为新节点，并使ptail指向队列的末尾节点。
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	else//队列为空的情况。
	{
		pq->phead = pq->ptail = newnode;
	}
	pq->size++;
}

       入队列就是链表中的尾插操作。

3.判断栈是否为空

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

4.出队列

//出队列
void QueuePop(Queue* pq)
{
	assert(pq);
	if (pq->phead == NULL)//如果队列为空，则不能执行出队列操作。
	{
		return;
	}
	if (pq->phead == pq->ptail&&pq->phead !=NULL)//队列里面只有一个节点
	{
		pq->ptail == NULL;
		return;
	}
	else
	{
		QNode* ptmp = pq->phead->next;
		free(pq->phead);
		pq->phead = ptmp;
		pq->size--;
		return;//使用一个临时变量保存至要删除的节点的下一个节点，当释放过该节点之后让头节点指向下一个节点
	}
}

5.取队头

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

       取队头就是将对头的元素作为返回值返回出去。

6.取队尾

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

       取队尾的操作和取队头一样。

7.统计队列中的元素个数

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

8.队列的销毁

//销毁
void QueueDestory(Queue* pq)
{
	assert(pq);
	QNode* pcur = pq->phead;
	while (pcur)
	{
		QNode* pnext = pcur->next;
		free(pcur);
		pcur = pnext;
	}
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}

       至此我们就实现了队列。