【数据结构】栈和队列的代码实现

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

今天我们来了解一下数据结构中的两个板块：栈和队列。这一部分呢相对比较简单。它是建立在顺序表和链表之上的。所以我们要对顺序表和链表十分的熟悉。小编呢将会对两部分单独讲解。那现在让我们来看看什么是栈和队列吧！

---

一、队列

我们这里呢将会从队列的概念及结构 和 队列的代码实现这两方面来讲解什么是队列?

1.队列的概念及结构

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

2.队列的代码实现

我们这里要怎样来实现队列呢？其实队列也可以数组和链表的结构实现，那我们这里是用数组呢还是链表呢？其实这里用链表要好一点。那为什么呢？因为链表与数组最大的不同就在于删除、插入的性能优势，由于链表是非连续的内存，所以不用像数组一样在插入、删除操作的时候需要进行大面积的成员位移，比如在a、b节点之间插入一个新节点c，链表只需要： a断开指向b的指针，将指针指向c c节点将指针指向b，完毕 这个插入操作仅仅需要移动一下指针即可，插入、删除的时间复杂度只有O (1).

1.队尾插入数据
既然我们这里使用单链表来实现队列，所以这里的队尾插入就是我们单链表的尾插。那么我们这里来想一个问题，我们这里是不是每次插入一个数据都要遍历一遍之后在插入啊！那么这里的插入效率是不是就变低了呀？那要怎样来解决这个问题呢？那可不可以设置两个指针来完成呢？一个指向头节点，一个指向尾节点。如下图所示：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int SLDataType;
typedef struct QueueNode
{
	SLDataType data;
	struct QNode* next;
}QNode;
void QueuePush(QNode**phead,QNode**ptail, SLDataType x)//队尾插入

大家看看这样行不行呢？这样其实也没啥问题。但是我个人觉得比较复杂而且还不容易理解，因为这里的参数比较多而且还涉及到了二级指针。那有没有一种解决方式同时解决这样的问腿呢？答案是：肯定有的。这里我们只需要在定义一个结构体就ok呀，把这两个指针放在结构体里面去。

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int SLDataType;
typedef struct QueueNode
{
	SLDataType data;
	struct QNode* next;
}QNode;
typedef struct Quene
{
	QNode* phead;
	QNode* ptail;
	SLDataType size;
}Queue;
void QueuePush(Queue*pq, SLDataType x)//队尾插入

这里为什么我们要传结构体的指针过去呢？其实在我们没有使用结构体的时候是不是要改变phead和ptail这两个成员。如果要改变结构体的指针，我们要用结构体的指针的指针。但是现在呢？我们这里只需要改变结构体就行了呀!是不是就解决了二级指针的问题了呢？

ok，了解了这些之后呢？我们再来看看在队尾插入数据。先来看代码：

void QueuePush(Queue* pq, SLDataType x)//队尾插入
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail\n");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->ptail == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}

这里的szie呢就是用来计算队列的长度的。

2.队列的初始化

根据单链表的知识，我们不难可以写出代码：

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

size呢上面已经说过了是用来计算队列的长度的。
3.队头的删除

这里呢我们也分为两种情况：一是只有一个节点时，二是有多个节点时；面对两种不同情况呢，解决的方法也不一样：先看代码的实现：

void QueuePop(Queue* pq)//队头删除
{
	assert(pq);
	assert(pq->size !=0);
	if (pq->phead->next == NULL)
	{
		free(pq->phead);
		pq->phead =pq->ptail = NULL;
	}
	else
	{
		QNode* new = pq->phead->next;
		free(pq->phead);
		pq->phead = new;
	}
	pq->size--;
}

这里需要注意的时队列不能为空哦。这里可能会有小伙伴会问了。那为什么我们把phead给释放了，那为什么不释放ptail呢？其实当只有一个节点的时候，phead和ptail指向的是同一个节点。我们这里是释放指针指向的节点而不是指针，所以这里不需要释放ptail。

4.队列的销毁
先看代码

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

这里呢没啥需要注意的，那由于后面的代码比较简单，那我就直接把队列剩下的代码就直接写出来了，有啥不理解的地方咋们评论区见哦。
5.队列的相关代码

SLDataType QueueFront(Queue* pq)//队头数据
{
	assert(pq);
	assert(pq->phead);
	return pq->phead->data;
}
SLDataType QueueBank(Queue* pq)//队尾数据
{
	assert(pq);
	assert(pq->ptail );
	return pq->ptail->data;
}
bool QueueEmpty(Queue* pq)//判空
{
	assert(pq);
	return pq->size == 0;
}
int	QueueSize(Queue*pq)//队列长度
{
	assert(pq);
	return pq->size;
}

6.队列的代码实现

typedef int SLDataType;
typedef struct QueueNode
{
	SLDataType data; 
	struct QNode* next;
}QNode;
typedef struct Quene
{
	QNode* phead;
	QNode* ptail;
	SLDataType size;
}Queue;
void QueueInit(Queue* pq)//初始化
{
	assert(pq);
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}
void QueuePush(Queue* pq,SLDataType x)//队尾插入
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail\n");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->ptail ==NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail ->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}
int	QueueSize(Queue*pq)//队列长度
{
	assert(pq);
	return pq->size;
}
void QueuePop(Queue* pq)//队头删除
{
	assert(pq);
	assert(pq->size !=0);
	if (pq->phead->next == NULL)
	{
		free(pq->phead);
		pq->phead =pq->ptail = NULL;
	}
	else
	{
		QNode* new = pq->phead->next;
		free(pq->phead);
		pq->phead = new;
	}
	pq->size--;
}
void QueueDestory(Queue* pq)//销毁
{
	assert(pq);
	QNode* cur = pq->phead;
	while (cur)
	{
		QNode* next = pq->phead->next;
		free(cur);
		cur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}
SLDataType QueueFront(Queue* pq)//队头数据
{
	assert(pq);
	assert(pq->phead);
	return pq->phead->data;
}
SLDataType QueueBank(Queue* pq)//队尾数据
{
	assert(pq);
	assert(pq->ptail );
	return pq->ptail->data;
}
bool QueueEmpty(Queue* pq)//判空
{
	assert(pq);
	return pq->size == 0;
}
int main()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
    printf("%d ", QueueFront(&q));
	QueuePop(&q);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	printf("\n"); 
	return 0;
}

这里呢我们可以边进边出，或者全部进去之后再出来，反正出来的结果是不会发生改变的。


大家可以看这两个的运行结果都是一样的。

一、栈

好啦，这里小编相信大家多多少少对队列都有所了解了吧，那现在我们来看看栈的相关知识吧。这里呢我们呢 还是分为两部分：栈的概念及结构和 栈的代码实现

1.栈的概念及结构

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

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

结构：

2.栈的代码实现

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

这是栈的相关函数实现，接下来就一个个的来了解一下；
1 .栈的初始化
先来看代码：

typedef int SLDataType;
typedef struct Stack
{
	SLDataType *arr;
	int top;//栈顶
	int catacity; 
}ST;
void STInit(ST* ps)//初始化
{
	assert(ps);
	ps->arr = NULL;
	ps->catacity = ps->top = 0;
}

这里需要注意的是：top是指向尾的呢还是指向下一个尾的下一个位置呢？这里呀要根据自己的习惯来决定，他有两种情况，但是后面的代码也要衔接，如果你的top是指向的栈顶元素，那么初始化就不能会给0，那为什么呢？如果这里给0了，当top=0的时候那他就会有元素的呀。所以top这时要为-1，如果是指向尾的下一个位置呢？那么他就可以为0；

这里选择不同的方式然而后面的代码也要有所改变了 ：当然我这里选择的时第二种：当top时指向栈顶数据的下一个位置。
2.进栈

void STPush(ST* ps,SLDataType x)//进栈
{
	assert(ps);
	if (ps->top == ps->catacity)
	{
		int  newcatacity = ps->catacity == 0 ? 4 : 2 * ps->catacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, newcatacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc fail\n");
			exit(1);
		}
		ps->arr = tmp;
		ps->catacity = newcatacity;
	}
	ps->arr[ps->top] = x;
	ps->top++;
}

这里需要注意的是top++。这里如果初始化top=-1时，那么这里就要交换最后两行代码了。的想让top++然后在插入数据。
2.出栈

void STPop(ST* ps)//出栈
{
	assert(ps);
	assert(ps->top > 0);
	ps->top--;
}

这里就需要注意断言这里的一定要让栈不为空，不然就不会运行

3.栈的销毁

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

栈的销毁呢和顺序表的销毁大同小异，注意的是就是栈不能为空。
4.取出栈顶元素，判断栈是否为空，获取数据个数

SLDataType STTop(ST* ps)//取出栈顶数据
{
	assert(ps);
	assert(ps->top > 0);
	return ps->arr[ps->top - 1];
}
bool STEmpty(ST* ps)//判断是否为空表
{
	assert(ps);
	return ps->top==0;
}
int STsize(ST* ps)//获取数据个数
{
	assert(ps);
	return ps->top;
}

5.栈的代码展示与运行结果

typedef int SLDataType;
typedef struct Stack
{
	SLDataType *arr;
	int top;//栈顶
	int catacity; 
}ST;
void STInit(ST* ps)//初始化
{
	assert(ps);
	ps->arr = NULL;
	ps->catacity = ps->top = 0;
}
void STDestory(ST* ps)//销毁
{
	assert(ps);
	assert(ps->top > 0);
	free(ps->arr);
	ps->arr = NULL;
	ps->catacity = ps->top = 0;
}
void STPush(ST* ps,SLDataType x)//进栈
{
	assert(ps);
	if (ps->top == ps->catacity)//扩容
	{
		int  newcatacity = ps->catacity == 0 ? 4 : 2 * ps->catacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, newcatacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc fail\n");
			exit(1);
		}
		ps->arr = tmp;
		ps->catacity = newcatacity;
	}
	ps->arr[ps->top] = x;
	ps->top++;
}
void STPop(ST* ps)//出栈
{
	assert(ps);
	assert(ps->top > 0);
	ps->top--;
}
SLDataType STTop(ST* ps)//取出栈顶数据
{
	assert(ps);
	assert(ps->top > 0);
	return ps->arr[ps->top - 1];
}
bool STEmpty(ST* ps)//判断是否为空表
{
	assert(ps);
	return ps->top==0;
}
int STsize(ST* ps)//获取数据个数
{
	assert(ps);
	return ps->top;
}

int main()
{
	ST s;
	STInit(&s);
	STPush(&s, 1);
	STPush(&s, 2);
	STPush(&s, 3);
	STPush(&s, 4);
	while (!STEmpty(&s))
	{
		printf("%d ", STTop(&s));
		STPop(&s);
	}
	return 0;
}

这里还有一些代码话没有展现出不来，如果有问题的，我们评论区见。同时也希望大家给小编提出一些宝贵的意见，这样小编才能写出更好文章。蟹蟹啦！

---

总结

今天的分享就到这里吧！关注小编，你们的点赞和建议就是小编前进的动力。加油每一天！冲鸭！！