分分钟让你学会栈和队列

数据结构——栈和队列

🏖️专题：数据结构
🙈作者：暴躁小程序猿
⛺简介：双非本科大二小菜鸟一枚，希望我的博客可以对大家有所帮助

---

---

前言

  我们之前学习了线性表中的顺序表和链表，链表具体学习了单链表和带头双向循环列表，链表如果细分的话可以分为8种，我们就不一一赘述，今天我们要学习的是线性表中另外两种数据结构——栈和队列，这两个数据结构很有特点，每一个都有自己独特的属性，但是两者也可以互相实现，即可以用队列实现栈，用栈实现队列，我们就进入今天的学习分享。

---

一、什么是栈？

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

二、栈的相关概念

1.压栈（入栈）

栈的插入操作叫做进栈/压栈/入栈，入数据必须在栈的在栈顶。

2.出栈

出栈：栈的删除操作叫做出栈。出数据也必须在在栈顶。

三、栈的实现

  栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为我们栈只可以从一端插入删除，这个时候刚好避免了顺序表（数组）的缺点，也就是头插和头删需要不停的移动整个数组的元素的问题，只在数组在尾上插入数据的代价比较小，同时尾部删除数据也很方便，所以优先使用顺序表实现。

3.1静态栈的定义

代码如下（示例）：

// 下面是定长的静态栈的结构，实际中一般不实用，
//我们主要实现后面的支持动态增长的栈
typedef int STDataType;
#define N 10
typedef struct Stack
{
STDataType _a[N];
int _top; // 栈顶
}Stack;
1
2
3
4
5
6
7
8
9

静态的栈就像之前的静态顺序表一样，每次申请多大空间未知，申请空间少了不够使用，但是申请多了又会造成空间浪费，在实际应用中非常的不方便，所以我们一般不用静态栈，而是用支持动态增长的栈。

3.2支持动态增长的栈

我们下面实现支持动态增长的栈：

3.2.1 头文件

代码如下（示例）：

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;
//初始化
void StackInit(ST* ps);
//销毁栈
void StackDestroy(ST* ps);
//入栈
void StackPush(ST* ps, STDataType x);
//出栈
void StackPop(ST* ps);
//取出栈顶数据
STDataType StackTop(ST* ps);
//判断栈是否为空
bool StackEmpty(ST* ps);
//栈的大小
int StackSize(ST* ps);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

  在头文件中我们定义了栈的结构体，同时对栈的一些将要实现的基本功能进行了声明，栈只可以在栈顶操作数据，所以栈的功能相对链表来说就少一些，具体的栈的功能实现代码在.c文件中。

3.2.2.函数功能实现文件

代码如下（示例）：

#define _CRT_SECURE_NO_WARNINGS
#include"stack.h"
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		STDataType newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a = x;
	ps->top++;
}
void StackPop(ST* ps)
{
	assert(ps);
	ps->top--;
}
STDataType StackTop(ST* ps)
{
	assert(ps);
	return ps->a[ps->top - 1];
}
bool StackEmpty(ST* ps) 
{
	assert(ps);
	return ps->top != 0;
}
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

在这个文件里面我们来实现栈的具体功能，

1.栈的初始化

代码如下;

void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
1
2
3
4
5
6

  我们先传入一个结构体指针，首先判断这个指针是否为NULL，这里采用断言的方式来暴力判断，如果不为NULL，那么我们将这个结构体的a成员置为NULL，同时让结构体的top和容量capacity都为0，初始化就结束了。

2.压栈

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		STDataType newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a = x;
	ps->top++;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

  压栈的操作很关键，我们传入一个结构体指针和要压入栈的数据，如果我们的top和栈的容量capacity相等，那么说明我们的栈已经不能插入数据了，有两个情况：
1.栈的容量本身就是0，所以没有空间可以插入数据，再插入之前top就等于capacity。
2.栈的容量满了，不能插入数据。
  我们这里利用三目操作符，判断一下结构体指针所指向栈的容量是否为0，如果为0我们就给他4个字节空间，如果不为0，我们就将栈的容量扩大为原来的2倍。我们用一个新指针newcapacity来接收，如果realloc增容成功就会返回一个指针，然后我们就将这个newcapacity赋给结构体所指向栈的容量，更新容量数据，如果为NULL那么我们就使用错误输出函数perror返回错误。
  其余功能就很容易，就不一一赘述，大家看代码就可以明白。

四、什么是队列？

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

五、队列的相关概念

队头：队列的头部，队列只允许从队头出数据。
队尾：队列的尾部，队列只能从队尾如数据。
具体如下图：

  通俗点来讲就是队列只允许按照一个方向进行操作，只能从队尾入数据，队头出数据，就像排队一样，从队尾排，排到队头才可以出，同理，先进去的先出，和栈的后进先出刚好相反。

六、队列的实现

  队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，每次出数据都要让后面的数据依次向前移动，如果要出n个数据，它的时间复杂度就是o（n^2),时间效率低下，所以优先使用链表来实现。

七、队列的代码实现

7.1头文件

代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include
typedef int QDataType;
typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QNode;
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	QDataType size;
}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);
//判断队列是否为空
bool QueueEmpty(Queue* pq);
//计算队列的大小
int QueueSize(Queue* pq);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

7.2函数功能实现

#define _CRT_SECURE_NO_WARNINGS
#include"queue.h"
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* del = cur;
		cur = cur->next;
		free(del);
	}
	pq->head = pq->tail = NULL;
}
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	pq->size++;
}
void QueuePop(Queue* pq)
{
	assert(pq);
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->size--;
}
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head != NULL);
	return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->tail != NULL);
		return pq->tail->data;
}
int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return (pq->head != NULL && pq->tail != NULL);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

7.2.1 队列的初始化

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
	pq->size = 0;
}
1
2
3
4
5
6

队列的初始化很简单，就是将队列的头指针和尾指针都只为NULL，然后队列的size也置为0即可。

7.2.2 入队

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	pq->size++;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

  我们实现队列采用的是单链表，所以我们每次要插入一个数据的时候再申请一个结点，什么时候用什么时候申请，也是按照需要申请指定的数目，不会造成空间浪费。我们将要插入的数据放到新结点的data域内，因为我们队列只能从队尾插入，所以新插入的结点背后暂时没有其他结点，所以我们将新结点的next指针域置为NULL，再判断结构体指针指向的队列的tail指针是否为NULL，如果为NULL说明我们队列中没有任何数据，head指针和tail一定同时指向NULL，我们将新结点赋给head指针和tail指针，如果结构体指针所指向的队列的tail指针不为NULL，说明我们的队列中已经有了数据，那么我们的head指针一定不为NULL，插入是在队尾，我们只需要将新结点给tail指针即可，插入操作就完成了。

7.2.3 出队

void QueuePop(Queue* pq)
{
	assert(pq);
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	pq->size--;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

  我们要出队只能从队头出队，首先我们判断一下head->next是否为NULL，如果为空就说明head现在指向的结点就是队列的最后一个结点了，我们直接free了然后将head和tail都置为NULL。如果不为空，那么我们用一个next结构体指针来接收我们要出队的队头结点的下一个结点，防止free头指针所指向的空间后找不到下一个节点的位置，保存后释放头指针然后再将我们保存的next的结构体指针赋给head，因为出队了，所以队列中的结点肯定会减少，所以我们将size–，这样就完成了出队操作。

总结

  今天分享了关于数据结构初阶的栈和队列的相关知识，包括什么是栈和队列，用什么数据结构来实现栈和队列更为方便和使用，以及代码如果实现这两种数据结构，栈和队列都有各自的特点，牢记他们的特点才可以正确使用，接下来就要进入数据结构的难点之一——二叉树了，希望我的博客对大家有所帮助，欢迎各位私信，我们明天见~