“数据结构：超详细栈与队列的概念与实战实现“

pp-周子晗（努力赶上课程进度版）

已于 2024-07-18 13:41:37 修改

阅读量730

点赞数 9

分类专栏：数据结构文章标签：数据结构链表动态规划 c语言经验分享 visual studio

于 2024-07-18 09:00:00 首次发布

本文链接：https://blog.csdn.net/2303_77756141/article/details/140506549

版权

数据结构专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、栈

1.1 栈的概念

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

1.1.a 趣味性解释：

想象一下，栈（Stack）就像是一个超级有纪律的自助餐排队区，不过这里的“吃”是指享受美食，而是指数据元素的“进出”。在这个特别的“餐厅”里，所有顾客（数据元素）都必须遵守一条严格的规则：只能从队伍的同一端（栈顶）加入或离开。

你作为一个新顾客（新数据元素）加入了这个队伍，但你发现队伍的另一端（栈底）已经排起了长龙，而且大家都静静地等着，没有人能从中间或者队伍的另一头插队或离开。这里，最靠近门口（即栈顶）的位置是最“热门”的，因为无论是新来的还是准备离开的，都只能在这里进行。

当你加入队伍后（即数据元素被插入栈中），你就站在了队伍的最后面，也就是离门口最近的地方。但是，如果你想快点吃到东西（或者说，数据元素想要被处理），你就得等待前面所有的人（前面的数据元素）都处理完（即被删除）之后才行。这就是所谓的“后进先出”（LIFO）原则，就像是你最后到的，却得等最久才能吃到东西。

如果突然有紧急情况，比如餐厅要关门了，那么最后一个加入队伍的人（最后插入栈的数据元素）将会是第一个被请出去的人（第一个被删除的数据元素），因为他/她站在离门口最近的地方。这就是栈的独特之处，它总是最关心最近加入的成员。

所以，栈不仅仅是一个数据结构，它更像是一个有趣的社会现象，在这个现象中，每个成员都遵循着“后来者居上，先走”的奇妙规则。

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

出栈:占的删除操作叫做出栈。出数据也在栈顶。

1.2 栈的结构

二、队列

2.1 队列的概念

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

1.1.a 趣味性解释：

想象一下，队列是一个魔法传送带的奇幻世界，而这个世界里的居民（也就是数据元素）都遵循着一种古老而神秘的规则——先进先出。在这个世界里，有两个特别的“门户”：一个叫做“奇幻入口”（队尾），另一个则是“时光出口”（队头）。

奇幻入口（队尾）：每当夜幕降临，来自不同地方的居民们（新的数据元素）会聚集在“奇幻入口”前，准备踏上这场奇妙的旅程。他们一个个地，按照到达的先后顺序，轻轻地踏入这个闪烁着微光的入口，就像是加入了一个神秘而有序的队列。这个过程，就是我们所说的“入队列”，而那个入口，自然就是队列的“队尾”了。

时光出口（队头）：随着时间的推移，当传送带上的居民们（数据元素）缓缓前行，他们最终会来到一个光芒四射的出口——“时光出口”。这里，是他们结束旅程，开始新生活的地方。但请记住，只有最先踏入奇幻入口的居民，才能最先到达时光出口。这种奇妙的安排，正是“先进先出”原则的体现。当居民们穿过时光出口，他们就像是完成了队列的“出队列”操作，开始了各自的新篇章。

在这个魔法传送带的奇幻世界里，每一个居民都享受着这段有序而神秘的旅程。他们知道，无论何时加入，只要耐心等待，总有一天会轮到自己穿越时光出口，迎来新的开始。而这一切，都得益于那个古老而神圣的“先进先出”原则，它让这个奇幻世界充满了秩序与和谐。

2.2 队列的结构

请注意：队列是先进先出

队列的插入是尾插，队列的删除是头删。与栈的后进先出是有区别的。

具体呈现在下一篇文章所讲述的oj题中。

三、栈的实现

3.1.1 程序结构

a. Stact.h

一个栈的实现包括初始化出入栈、销毁栈、获取栈顶元素、获取栈中元素个数，判空，销毁栈。因此我们需要实现相应的函数。
// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
   STDataType* _a;
   int _top;       // 栈顶，和链表不太一样但是相当于size
   int _capacity; // 容量
}Stack;
// 初始化栈
void StackInit(Stack* ps);
// 入栈
void StackPush(Stack* ps, STDataType data);
// 出栈
void StackPop(Stack* ps);
// 获取栈顶元素
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps);
// 销毁栈
void StackDestroy(Stack* ps);

b. Stact.c

接下来我们将对每个函数的实现进行详细的讲解，完整代码在文章末尾处。

1.栈的初始化：void StackInit(Stack* ps)

void StackInit(Stack* ps)
{
   assert(ps);//断言，判断传入的值是否有意义
   ps->_a = NULL;
   ps->_capacity = 0;
   ps->_top = -1;//top指向栈顶元素/先++再赋值
}

提问：top到底是什么？
top代表的是什么？是栈顶元素，还是栈顶元素的下一个？

pst->top =-1 表示top指向栈顶元素----------------先++再赋值

pst->top = 0 表示指向栈顶元素的下一个元素--先赋值后++
重要性于数据值的存入问题：先++再赋值还是赋值后++

2.入栈：void StackPush(Stack* ps, STDataType data)
void StackPush(Stack* ps, STDataType data)
{
assert(ps);
思路1：判断栈内空间是否足够,什么时候栈内空间需要扩容。
由于top相当于栈的大小，因此可使用top与capacity进行比较。

   if (ps->_top + 1 == 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 fail");
           return;
       }
       ps->_a = tmp;
       ps->_capacity = newcapacity;
   }
   ps->_top++;
   ps->_a[ps->_top] = data;}

1. 思考top = 0时的区别。
2.注意：ps->a相当于是得出的地址，相当于数组名。

3.realloc： void *realloc(void *mem_address, unsigned int newsize);

情况1.原有空间之后有足够大的空间：要扩展内存就直接原有内存之后直接追加空间
情况2.原有空间之后没有足够大的空间：在堆空间上另找一个合适大小的连续空间来使用，这样函数返回的是一个新地址，因此我们这里所遇到的是情况2

3.出栈：void StackPop(Stack* ps)

void StackPop(Stack* ps)
{
   assert(ps);
   assert(ps->_top >= 0);//top最小值就是-1，可思考与top=0时的区别
   ps->_top--;
}

4.取栈顶元素：STDataType StackTop(Stack* ps)

STDataType StackTop(Stack* ps)
{
   assert(ps);
   assert(ps->_top >= 0);
   return ps->_a[ps->_top];

}

5.取栈中有效元素个数：int StackSize(Stack* ps)

int StackSize(Stack* ps)
{
assert(ps);
return ps->_top+1;//思考与top = 0时的区别
}

6. 检测栈是否为空：int StackEmpty(Stack* ps)

如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps)
{
assert(ps);
return ps->_top == -1;//思考与top = 0时的区别

7.销毁栈： void StackDestroy(Stack* ps)

void StackDestroy(Stack* ps)
{
   assert(ps);
   free(ps->_a);//防止成为野指针
   ps->_a = NULL;
   ps->_top = -1;
   ps->_capacity = 0;
}

c.测试用例：

自行分析（后进先出）

int main()
{
   Stack pst;
   StackInit(&pst);
   StackPush(&pst, 1);
   StackPush(&pst, 2);
   StackPush(&pst, 3);
   printf("%d ", StackTop(&pst));
   StackPop(&pst);
   StackPush(&pst, 4);
   while (!StackEmpty(&pst))
   {
       printf("%d ", StackTop(&pst));
       StackPop(&pst);
   }
   printf("\n");
   return 0;
}

结果：3 4 2 1

四、队列的实现

a.Queue.h

typedef int QDataType;

//链式结构，表示队列
typedef struct QListNode
{
   struct QListNode* _next;//结构体指针
   QDataType _data;//数据类型
}QNode;//结构体变量名称

// 队列的结构
typedef struct Queue
{
   QNode* _front;
   QNode* _rear;
   int size;
}Queue;

// 初始化队列
void QueueInit(Queue* q);
// 队尾入队列
void QueuePush(Queue* q, QDataType data);
// 队头出队列
void QueuePop(Queue* q);
// 获取队列头部元素
QDataType QueueFront(Queue* q);
// 获取队列队尾元素
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
int QueueEmpty(Queue* q);
// 销毁队列
void QueueDestroy(Queue* q);

b.Queue.c

接下来我们将进行每个函数的实现，完整代码在文章末尾处。

1. 初始化队列：void QueueInit(Queue* q)

void QueueInit(Queue* q)
{
   assert(q);
   q->_front = q->_rear = NULL;
   q->size = 0;
}

2. 队尾入队列：void QueuePush(Queue* q, QDataType data)

void QueuePush(Queue* q, QDataType data)队列的尾插
{
   assert(q);
   QNode* newnode = (QNode*)malloc(sizeof(QNode));
   if (newnode == NULL)
   {
       perror("malloc fail");
   }
   newnode->_data = data;
   newnode->_next = NULL;
   if (q->_rear == NULL)
   {
       q->_front = q->_rear = newnode;

}
   else
   {
       q->_rear->_next = newnode;//要先建立连接
       q->_rear = newnode;//是尾插哦
   }
   q->size++;//不要忘记写了
}

3. 队头出队列：void QueuePop(Queue* q)

void QueuePop(Queue* q）
{
   assert(q);
   assert(q->_front);//因为需要头删，所以要判断头指针是否为空
   QNode* del = q->_front;//因为是删除掉队列的第一个元素q->_front，因此要先保存
   q->_front = q->_front->_next;
   free(del);
   del = NULL;//记得free之后置空

   if (q->_front == NULL)//说明该队列只有一个节点
   {
       q->_rear = NULL;
   }
   q->size--;
}

4.获取队列头部元素： QDataType QueueFront(Queue* q)

QDataType QueueFront(Queue* q)
{
   assert(q);
   assert(q->_front);
   return q->_front->_data;
}

5. 获取队列队尾元素：QDataType QueueBack(Queue* q)

QDataType QueueBack(Queue* q)
{
   assert(q);
   assert(q->_rear);
   return q->_rear->_data;
}

6.获取队列中有效元素个数：int QueueSize(Queue* q)

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

7. 检测队列是否为空：int QueueEmpty(Queue* q)

如果为空返回非零结果，如果非空返回0
int QueueEmpty(Queue* q)
{
assert(q);
return q->_front == NULL;或者q->_rear == NULL
}

8. 销毁队列：void QueueDestroy(Queue* q)

void QueueDestroy(Queue* q)
{
   assert(q);
   QNode* curnt = q->_front;//用于记录当前节点
   while (curnt)
   {
       QNode* next = curnt->_next;//一定要先保存下一个节点
       free(curnt);
       curnt = next;
   }
   q->_front = q->_rear = NULL;
   q->size = 0;
}

c.测试用例：

自行分析（先进先出）

int main()
{
   Queue q;
   QueueInit(&q);
   QueuePush(&q, 2);
   QueuePush(&q, 5);
   QueuePush(&q, 8);
   printf("%d ", QueueFront(&q));
   QueuePop(&q);//5 8
   printf("%d ", QueueFront(&q));
   QueuePop(&q);//8
   printf("%d ", QueueFront(&q));
   QueuePop(&q);//null
   QueuePush(&q, 3);
   QueuePush(&q, 7);
   while (!QueueEmpty(&q))
   {
       printf("%d ", QueueFront(&q));//
       QueuePop(&q);
   }
   QueueDestroy(&q);

   return 0;
}

结果：2 5 8 3 7

五、栈的实现完整代码

1.Stack.h

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;		
	int _capacity;  
}Stack;
void StackInit(Stack* ps);
void StackPush(Stack* ps, STDataType data);
void StackPop(Stack* ps);
STDataType StackTop(Stack* ps);
int StackSize(Stack* ps);
int StackEmpty(Stack* ps);
void StackDestroy(Stack* ps);

2.Stack.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Stact.h"
//初始化
void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a = NULL;
	ps->_capacity = 0;
	ps->_top = -1;
}
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	if (ps->_top + 1 == 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 fail");
			return;
		}
		ps->_a = tmp;
		ps->_capacity = newcapacity;
	}
	ps->_top++;
	ps->_a[ps->_top] = data;

}

void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->_top >= 0);
	ps->_top--;
}
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->_top >= 0);
	return ps->_a[ps->_top];

}
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top+1;
}

int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->_top == -1;
}

void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
    ps->_top = -1;
	ps->_capacity = 0;
}

六、队列实现的完整代码

1.Queue.h

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int QDataType;

typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
	int size;
}Queue;

void QueueInit(Queue* q);
void QueuePush(Queue* q, QDataType data);
void QueuePop(Queue* q);
QDataType QueueFront(Queue* q);
QDataType QueueBack(Queue* q);
int QueueSize(Queue* q);
int QueueEmpty(Queue* q);
void QueueDestroy(Queue* q);

2.Queue.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"
void QueueInit(Queue* q)
{
	assert(q);
	q->_front = q->_rear = NULL;
	q->size = 0;
}

void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
	}
	newnode->_data = data;
	newnode->_next = NULL;
	if (q->_rear == NULL)
	{
		q->_front = q->_rear = newnode;

	}
	else
	{
		q->_rear->_next = newnode;
		q->_rear = newnode;
	}
	q->size++;
}
void QueuePop(Queue* q)
{
	assert(q);
	assert(q->_front);
	QNode* del = q->_front;
	q->_front = q->_front->_next;
	free(del);
	del = NULL;

	if (q->_front == NULL)
	{
		q->_rear = NULL;
	}
	q->size--;
}

QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(q->_front);
	return q->_front->_data;
}

QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(q->_rear);
	return q->_rear->_data;
}

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

int QueueEmpty(Queue* q)
{
	assert(q);
	return (q->_front == NULL);
}

void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* curnt = q->_front;
	while (curnt)
	{
		QNode* next = curnt->_next;
		free(curnt);
		curnt = next;
	}
	q->_front = q->_rear = NULL;
	q->size = 0;
}

结语：

随着我们对栈与队列的深入探索，仿佛是在编织一场复杂而精妙的数据之舞。在这场舞蹈中，栈以其独特的“后进先出”步伐，优雅地展示着时间的逆行之美；而队列，则以它坚定的“先进先出”节奏，引领着我们前行，在数据处理的长河中留下坚实的足迹。

每一次栈的压入与弹出，都是对过往记忆的珍视与释放；每一次队列的入队与出队，都是对未来可能的期许与实践。它们不仅仅是数据结构的简单实现，更是思维方式的深刻体现，教会我们在解决问题时，既要懂得回顾与反思，也要勇于前瞻与尝试。

然而，正如舞蹈永无止境，数据结构的世界也充满了无限可能。栈与队列只是其中的两个音符，而整个数据结构的乐章，正等待着我们去发现、去创造、去演绎。让我们保持好奇心与探索欲，勇敢地踏入这片未知的领域，用我们的智慧和汗水，为数据结构的交响曲增添更多动人的旋律。

在此，我想向每一位读者致以最诚挚的感谢与祝福。感谢你们陪伴我一起走过了这段探索之旅，你们的关注与支持是我前进的动力。同时，我也深知自己的渺小与不足，愿我们都能以更加开放的心态，相互学习，共同成长。在未来的日子里，无论风雨兼程，我都将怀揣着对知识的渴望与对未知的敬畏，继续前行在知识的征途上。

最后，愿我们都能成为那个在数据海洋中翩翩起舞的舞者，用栈与队列的旋律，编织出属于自己的精彩篇章。