数据结构：栈和队列

前言

本章节较为抽象，我们先讲解概念，再进行举例。如有问题，欢迎评论区提问质疑。

栈

1.概念与结构

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

大家不妨把它想象成这么个杯子（栈），杯子里面是不同的液体（数据）。我们在加入新液体（入栈）的时候呢，新加入的液体会在最上层（大家别较真密度问题，就是一个比喻帮助大家理解）。我们如果想取出下层的液体呢，就需要将上面的液体倒掉（这就是栈结构的先进后出原则）。

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

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

2.栈的框架

一个数据结构通常具备增、删、查、改等基本功能。栈遵循后进先出原则，操作主要集中在栈顶，其入栈和出栈操作分别对应增和删。而由于栈不能遍历且只能在一端操作，它没有常规意义上的查找功能。

cpp 复制代码

typedef char STDataType;//方便更改存放数据的类型
typedef struct Stack
{
    STDataType* a;//数组指针
    int top;//栈顶位置
    int capacity;//数据结构容量
}ST;

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

// 销毁栈
void STDestroy(ST* ps);

// ⼊栈
void STPush(ST* ps, STDataType x);

//出栈
void STPop(ST* ps);

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

//栈是否为空
bool STEmpty(ST* ps);

3.栈的详解

(1)初始化栈

顾名思义，该函数的作用是将结构体中的数据全部初始化，指针置为空，整型置为0。

cpp 复制代码

void STInit(ST* ps)
{
	assert(ps);//判断ps不为空
	ps->arr = NULL;
	ps->capacity = ps->top = 0;
}

(2)销毁栈

该函数是在不再需要某个栈时的操作。将动态分配的内存释放掉，指针指向空，将其余数据归为初始状态。

cpp 复制代码

void STDestroy(ST* ps)
{
	assert(ps);
	if (ps->arr)
    {
        free(ps->arr);//释放内存
    }
	ps->arr = NULL;//指针指向空，防止野指针出现
	ps->top = ps->capacity = 0;
}

(3)入栈

该指针是向栈中压入数据时使用的。其主要功能是判断空间是否足够，如果不够，开辟新的空间。足够则将数据压入栈中即可。

cpp 复制代码

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	//1.判断空间是否足够
    //满足该if条件，则空间已满
	if (ps->capacity == ps->top)
	{
        //若空间为0，则赋初值为4.若非0，则开辟出原有空间2倍的空间
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		STDataType* tmp = (STDataType*)realloc(ps->arr, newCapacity * sizeof(STDataType));
		if (tmp == NULL)//判断空间是否开辟成功
		{
            //未成功开辟
			perror("realloc fail!");//显示报错
			exit(1);//若空间不足，非正常退出程序
		}
        //成功开辟
		ps->arr = tmp;//赋值为新开辟的地址
		ps->capacity = newCapacity;//将容量更新
	}
	//空间足够，直接赋值即可
	ps->arr[ps->top++] = x;
}

(4)判断栈是否为空

这个函数通常在出栈函数和获取栈顶元素时被调用。因为当栈为空时，我们将不能再执行出栈或者获取栈顶元素操作。

cpp 复制代码

bool StackEmpty(ST* ps)
{
	assert(ps);//判断ps指针不指向空
	return ps->top == 0;
}

(5)出栈

该出栈函数执行的是栈的标准出栈操作。遵循后进先出原则，出栈时将栈顶指针top减 1，使原栈顶元素被移除，新栈顶变为原栈顶元素的下一个。值得一提的是，出栈操作需在栈不为空时进行。

cpp 复制代码

void StackPop(ST* ps)
{
    //判ps指针是否为空
	assert(ps);
    //判该数据结构是否为空
	assert(!StackEmpty(ps));
    //出栈时别忘了给栈顶减1
	--ps->top;
}

(6)取栈顶元素

前面说过，我们的栈是不能被遍历的。那么我们在操作时就不能直接去对指针解引用访问数组，不然这和顺序表也就没什么区别了。所有我们需要封装一个专门调取栈顶元素的函数。

cpp 复制代码

//取栈顶元素
STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->arr[ps->top - 1];
}

4.小试牛刀

题目链接：. - 力扣（LeetCode）

题目信息

源码附注释

cpp 复制代码

#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>
typedef struct stack
{
	char* arr;
	int capacity;//栈容量
	int top;//数据个数
}ST;
void StackPush(char x,ST* ps)//进栈
{
	assert(ps);
	if(ps->capacity==ps->top)//满栈
	{
		int newcapacity=ps->capacity==0?4:ps->capacity*2;
		char* tem=(char*)realloc(ps->arr,newcapacity);
		assert(tem);//创建新空间失败
		ps->arr=tem;
	}
	ps->arr[ps->top++]=x;//将栈顶放置为新数据并将栈顶加一
}
bool StackEmpty(ST* ps)
{
    // 检查传入的指针是否有效，如果指针为空，则程序会在断言处终止并给出错误提示
    assert(ps);
    // 如果栈顶指针为 0，表示栈中没有任何元素，即栈为空
    return ps->top == 0;
}
void StackPop(ST* ps)//出栈
{
	assert(ps);
	assert(!StackEmpty(ps));//如果top==0返回值为ture，故非
	--ps->top;
}
void InitStack(ST* ps)//初始化栈
{
	assert(ps);
	ps->arr = NULL;
	ps->capacity=0;
	ps->top=0;
}
void DestroyStack(ST* ps)//销毁栈
{
    assert(ps);
    free(ps->arr);
    ps->arr = NULL;
    ps->capacity = 0;
    ps->top = 0;
}
char StackTop(ST* ps)//用于调取栈顶元素的函数
{
	assert(ps);
	assert(!StackEmpty(ps));//如果top==0返回值为ture，故非
	return ps->arr[ps->top-1];//返回栈顶元素
}
int main()
{
	ST stack;
	InitStack(&stack);
	char arr[100001];
	gets(arr);
	int flag=1;
	for(int i=0;i<strlen(arr);i++)
	{
		if(arr[i]=='{'||arr[i]=='['||arr[i]=='(')//如果是左半括号
		{
			StackPush(arr[i],&stack);//入栈
			flag=0;
		}
		else
		{
			if(!StackEmpty(&stack)==false)//
			{
				flag=0;
				break;
			}
			//如果arr数组中有右半括号，看栈顶元素是否与之对应
			if(arr[i]=='}'&&StackTop(&stack)=='{')
			{
				StackPop(&stack);
				flag=1;
			}	
			else if(arr[i]==']'&&StackTop(&stack)=='[')
			{
				StackPop(&stack);
				flag=1;
			}
			else if(arr[i]==')'&&StackTop(&stack)=='(')
			{
				StackPop(&stack);
				flag=1;
			}
			else
			{
				flag=0;
				DestroyStack(&stack);
				break;
			}
		}
	}
	if(strlen(arr)==0)//当什么都没有输入，结果为false
	{
		flag=0;
	}
	if(flag==1)
	{
		printf("true");
	}
	else
	{
		printf("false");
	}
	return 0;
}

需要注意的是，我这里写的是完整代码，而力扣上提交则是提交一个函数。代码截图如下：

队列

1.概念与结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊性表，队列具有新进先出的特性。

队列嘛，顾名思义，就像是一排数据结构在站队。新增添的数据只能排在队伍的最后，而想要出队列则需要从最前面出来。如图：

如果将栈喻为杯子，那队列就是管子，从一端进，另一端出。

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

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

2.队列框架

队列遵循先进先出原则，操作主要在队首（出队）和队尾（入队）。其入队操作(QueuePush)对应增加元素，出队操作(QueuePop)对应删除元素。对于查找功能，由于队列一般只能从队首开始依次遍历节点，相对效率较低，但也可通过遍历队列节点来查找特定元素。队列没有像顺序表那样可直接定位的高效查找方式。整体而言，队列的操作主要围绕入队、出队以及获取队首和队尾元素展开。

cpp 复制代码

//队列结点结构
typedef struct QueueNode
{
    //存放队列的结点所需变量
}QNode;
//队列结构
typedef struct Queue
{
    //存放队列所需变量
}Queue;
//初始化队列
void QueueInit(Queue* pq);
//销毁队列
void QueueDestroy(Queue* pq);
// ⼊队列，队尾
void QueuePush(Queue *pq, QDataType x);
// 出队列，队头
void QueuePop(Queue* pq);
//取队头数据
int QueueFront(Queue* pq);
//取队尾数据
int QueueBack(Queue* pq);
//队列判空
bool QueueEmpty(Queue* pq);

3.队列详解

(1)队列节点结构讲解

我们的队列是通过链表来实现的。因此包含两个元素，一是我们存放的数据，二便是指向下一节点的指针。代码如下

cpp 复制代码

//我们这里用链表举例来讲解队列
typedef struct QueueNode//队列节点
{
	int data;//存放数据
	struct QueueNode* next;//指向下一节点的指针
}QueueNode;

(2)队列结构体讲解

这里的队列结构体包含头结点的地址，可在此位置进行数据的插入操作；还包含尾节点的地址，用于在该位置进行数据的删除操作；同时，还有一个整型变量size，用于统计队列中的数据个数。

cpp 复制代码

//完整队列包含的基本数据
typedef struct Queue
{
	struct QueueNode* phead;//该指针指向队列头
	struct QueueNode* ptail;//该指针指向队列尾
	int size;//队列中存放的数据个数
}Queue;

(3)队列初始化

不用我过多解释了吧？指针置空，整型归0。

cpp 复制代码

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

(4) 队列判空

我们虽然判断了指针pq不为空，但是不排除pq指向了一个空队列的情况。这种情况下我们判断一下头指针只想是否为空即可。

cpp 复制代码

//队列判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->phead==NULL;
}

(5)入队列

这里的逻辑就是尾插。做法很简单，创建新节点以后将存储的数据放入节点即可。最后别忘了将为节点更新为最新创建的节点并给size++，我们来看一下示意图：

若队列为空，我们直接创建一个新的节点，并让头尾指针都直系那个该节点即可，如图：

若队列不为空，我们就创建一个新节点，先让当前尾节点指向最新结点，再将最新节点作为尾结点，示意图如下：

插入前：

插入后：

详细步骤请看源码：

cpp 复制代码

//入队列,从队尾入
void QueuePush(Queue* pq, int x)
{
	assert(pq);
	//申请新结点
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(1);//非正常退出
	}
	newnode->data = x;
	newnode->next = NULL;
	//队列为空
	if (pq->phead == NULL)
	{
		//队列为空时插入的第一个元素既是队头也是队尾
		pq->phead = pq->ptail = newnode;
	}
	//队列不为空
	else
	{
		pq->ptail->next = newnode;//先让当前尾节点指向最新结点
		pq->ptail = pq->ptail->next;//再将最新节点作为尾结点
	}
	pq->size++;
}

(6)出队列

这里的出队列要从头出。换句话说，就是将头结点删除了。示意图如下：

删除前：

删除后：

详细步骤请见代码：

cpp 复制代码

//出队列,从队头出
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	//当前队列只有一个结点的情况
	if (pq->ptail == pq->phead)
	{
		free(pq->phead);//释放该结点
		pq->phead = pq->ptail = NULL;//置空
	}
	else
	{
		//删除队头元素
		QueueNode* next = pq->phead->next;//将第二个结点的地址存入next
		free(pq->phead);//释放当前头结点
		pq->phead = next;//将next作为头结点
	}
	pq->size--;
}

(7)功能演示

其实就是刚刚的代码片段拼凑起来，并调用了几个出入队列的函数

演示代码如下：

cpp 复制代码

#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
#include<assert.h>
//我们这里用链表举例来讲解队列
typedef struct QueueNode//队列节点
{
	int data;//存放数据
	struct QueueNode* next;//指向下一节点的指针
}QueueNode;
typedef struct Queue
{
	struct QueueNode* phead;//该指针指向队列头
	struct QueueNode* ptail;//该指针指向队列尾
	int size;//队列中存放的数据个数
}Queue;
//队列初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}
//入队列,从队尾入
void QueuePush(Queue* pq, int x)
{
	assert(pq);
	//申请新结点
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(1);//非正常退出
	}
	newnode->data = x;
	newnode->next = NULL;
	//队列为空
	if (pq->phead == NULL)
	{
		//队列为空时插入的第一个元素既是队头也是队尾
		pq->phead = pq->ptail = newnode;
	}
	//队列不为空
	else
	{
		pq->ptail->next = newnode;//先让当前尾节点指向最新结点
		pq->ptail = pq->ptail->next;//再将最新节点作为尾结点
	}
	pq->size++;
}
//队列判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->phead == NULL;
}
//出队列,从队头出
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	//当前队列只有一个结点的情况
	if (pq->ptail == pq->phead)
	{
		free(pq->phead);//释放该结点
		pq->phead = pq->ptail = NULL;//置空
	}
	else
	{
		//删除队头元素
		QueueNode* next = pq->phead->next;//将第二个结点的地址存入next
		free(pq->phead);//释放当前头结点
		pq->phead = next;//将next作为头结点
	}
	pq->size--;
}
main()
{
	Queue q;//创建队列q
	QueueInit(&q);//初始化q队列
	QueuePush(&q, 1);//入队列
	QueuePush(&q, 2);//入队列
	QueuePush(&q, 3);//入队列
	QueuePop(&q);//出队列
	QueuePop(&q);//出队列
}

演示结果

我们先看一下，将1 2 3都放入队列中队列中的队列，如下图：

下面我们将出队列两次，看一下现在的队列：

队列是一种遵循先进先出原则的数据结构，通常由队首指针、队尾指针和元素个数等组成，支持入队（在队尾添加元素）、出队（从队首移除元素）等操作。

4.小试牛刀

今天搞累了，数据好的话明天就拓展一下。