数据结构 栈和队列

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

文章目录

• 前言
• 一、pandas是什么？
• 二、使用步骤
  • 1.引入库
  • 2.读入数据
• 总结

---

前言

---

一、栈的概念及结构

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

下图入栈顺序和出栈顺序为：

入栈：2，7，1，8，2

出栈：2，8，1，7，2

二、栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。（单链表头插也可以实现，效率也还行。单链表尾插需要找尾，代价比较大）

1.数组实现：

#define INIT_CAPACITY 3//定义初始栈的容量，在栈初始化时使用

typedef int STDataType;
typedef struct Stack {
	STDataType* a;
	int capacity;//栈的容量
	int top;//栈顶
}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);

// 初始化栈
void StackInit(Stack* ps);

// 初始化栈
void StackInit(Stack* ps)
{
	STDataType* tmp = (STDataType*)malloc(sizeof(STDataType)*INIT_CAPACITY);
	assert(tmp);
	ps->a = tmp;
	ps->capacity = INIT_CAPACITY;
	ps->top = 0;
}

这里的top可以设置为指向栈顶元素的下一个元素的位置或者设置为指向栈顶元素的位置。

指向栈顶元素的下一个：ps->top=0;在入栈时需要先插入元素在ps->top++;

指向栈顶元素              ：ps->top=-1;在入栈时需要先ps->top++;在插入元素。

这两种都可行，这里采用的是第一种。

// 入栈
void StackPush(Stack* ps, STDataType data);

// 入栈
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a,sizeof(STDataType) * ps->capacity*2);
		assert(tmp);
		ps->a = tmp;
		ps->capacity *= 2;
	}
	ps->a[ps->top] = data;
	ps->top++;

}

这里top指向的是栈顶的下一个元素位置，当top为0时，栈有0个元素；top为1时，栈有1个元素；

入栈时需要先判定栈是否栈满，栈满则需要用realloc扩容空间，记得capacity要乘扩容的倍数。

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps);

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps)
{
	assert(ps);

	return ps->top == 0;
}

// 出栈
void StackPop(Stack* ps);

// 出栈
void StackPop(Stack* ps)
{
	assert(ps);
	if (StackEmpty(ps))
	{
		return;
	}
	ps->top--;
}

出栈时需要判断栈是否为空，为空就什么操作都不进行，直接返回。因为用的是数组，出栈非常方便，只需要ps->top--；即可。

// 获取栈顶元素
STDataType StackTop(Stack* ps);

// 获取栈顶元素
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top-1];
}

这里top指向的时栈顶元素的下一个位置，所以栈顶元素的位置是top-1,这里不要写成top--。

如果指向的是栈顶元素，return ps->a[ps->top];

// 获取栈中有效元素个数
int StackSize(Stack* ps);

// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);

	return ps->top;
}

因为数组的下标是数组的元素个数+1。

top指向栈顶元素的下一个位置：top的初始值为0，栈空时返回top(0)，栈有3个元素时，返回top (3)，此时栈内有元素的位置是0，1，2。top此时为3。

top指向栈顶元素：top的初始值为-1，栈空时，代码要返回 return ps->top+1;,top此时是-1，表示栈为空，栈内有3个元素时，返回top+1 (2+1),此时栈内有元素的位置是0，1，2。top此时为2。

这里有点绕，可以画一个数组自己标一下下标，更容易理解。

// 销毁栈
void StackDestroy(Stack* ps);

// 销毁栈
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
}

这里因为使用了malloc堆ps->a开辟了在堆上的数据，使用完后需要释放掉。指针a存放的是开辟空间的首地址。

2.单链表头插实现：

代码如下（示例）：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
import  ssl
ssl._create_default_https_context = ssl._create_unverified_context

三、队列的概念

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

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

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

1.队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。(如果用数组实现每次插入都需要挪动数据)下面是用链表实现的队列。

typedef int QDataType;
//队列节点
typedef struct QueueNode {
	QDataType x;
	struct QueueNode* next;
}QNode;

typedef struct Queue {
	QNode* head;
	QNode* tail;
	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);

// 初始化队列
void QueueInit(Queue* q);

// 初始化队列
void QueueInit(Queue* q)
{
	assert(q);
	q->head = q->tail = NULL;
	q->size = 0;
}

// 队尾入队列
void QueuePush(Queue* q, QDataType data);

// 队尾入队列
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	assert(newnode);
	
	newnode->x = data;//放入数据
	newnode->next = NULL;

	if (q->head == NULL)
	{
		q->head = q->tail = newnode;//为空队列时
	}
	else
	{
        //不为空时
		q->tail->next = newnode;
		q->tail = newnode;
	}
	q->size++;//队列长度
}

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
int QueueEmpty(Queue* q);

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
int QueueEmpty(Queue* q)
{
	return q->size == 0;
}

// 队头出队列
void QueuePop(Queue* q);

// 队头出队列
void QueuePop(Queue* q)
{
	assert(q);
	if (QueueEmpty(q))//队列为空，不进行任何操作直接返回
	{
		return;
	}
	QNode* next = q->head->next;//保存第二个节点
	free(q->head);//自己开辟的空间，含着泪也要释放掉
	q->head = next;//新的队头
	q->size--;
}

注意内存泄露就不会出太大问题。

// 获取队列头部元素
QDataType QueueFront(Queue* q);

// 获取队列头部元素
QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));//判断队列是否为空
	return q->head->x;
}

// 获取队列队尾元素
QDataType QueueBack(Queue* q);

// 获取队列队尾元素
QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));//判断队列是否为空
	return q->tail->x;
}

// 获取队列中有效元素个数
int QueueSize(Queue* q);

// 获取队列中有效元素个数
int QueueSize(Queue* q)
{
	assert(q);
	return q->size;
}

// 销毁队列
void QueueDestroy(Queue* q);

// 销毁队列
void QueueDestroy(Queue* q)
{
    //用QueuePop函数也可以销毁队列
	assert(q);
	/*while (!QueueEmpty(q))
	{
		QueuePop(q);
	}*/
	QNode* cur = q->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	q->head = q->tail = NULL;
	q->size = 0;
}

2.循环队列的概念和实现

循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。环形队列可以使用数组实现，也可以使用循环链表实现。

这里用一道题来讲解循环队列：622. 设计循环队列 - 力扣（LeetCode）

 

typedef struct {
    int *a;//循环队列的空间，本质就是一个数组
    int head;
    int tail;   
    int k; //循环队列的长度
} MyCircularQueue;
//判断循环队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
//判断循环队列是否为满
bool myCircularQueueIsFull(MyCircularQueue* obj);
//循环队列的初始化
MyCircularQueue* myCircularQueueCreate(int k);
//入队列
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value);
//出队列
bool myCircularQueueDeQueue(MyCircularQueue* obj);
//获取队头元素
int myCircularQueueFront(MyCircularQueue* obj);
//获取队尾元素
int myCircularQueueRear(MyCircularQueue* obj);
//销毁循环队列
void myCircularQueueFree(MyCircularQueue* obj);

//判断循环队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj);

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    if(obj->head==obj->tail)
    {
        return true;
    }
    return false;
}

//判断循环队列是否为满
bool myCircularQueueIsFull(MyCircularQueue* obj);

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    int h=obj->head;
    int t=(obj->tail+1)%(obj->k+1);
    if(h==t)
    {
        return true;;
    }
    return false;
}

//循环队列的初始化
MyCircularQueue* myCircularQueueCreate(int k);

MyCircularQueue* myCircularQueueCreate(int k) {
    //这是开辟了一个循环队列类型的空间（MyCircularQueue类型的空间）
    MyCircularQueue* mq=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    assert(mq);
    //这是开辟了一个存放队列数据的空间，就是为MyCircularQueue中的a开辟的。
    //这里的k+1是为了区分队列满和队列为空的情况
    //当rear==front时为空
    //当rear+1==front时为满
    int* tmp=(int*)malloc(sizeof(int)*(k+1));
    assert(tmp);
    mq->head=mq->tail=0;
    mq->k=k;
    mq->a=tmp;
    return mq;
}

这里的k+1是为了区分队列满和队列为空的情况
当head==tail时为空
当tail+1==head时为满

可以看上面的那个情况图让自己更好了解循环队列的空和满的情况。

//入队列
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value);

//入队列
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    //判满
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->tail]=value;
    obj->tail++;
    (obj->tail)%=(obj->k+1);
    return true;
}

这里用的是数组，tail在++时要注意数组下表越界，需要进行膜处理一下。

//出队列
bool myCircularQueueDeQueue(MyCircularQueue* obj);

//出队列
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    //判空
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->head++;
    (obj->head)%=(obj->k+1);
    return true;
}

这里用的是数组，head在++时要注意数组下表越界，需要进行膜处理一下。

//获取队头元素
int myCircularQueueFront(MyCircularQueue* obj);

int myCircularQueueFront(MyCircularQueue* obj) {
    //判断队列是否为空
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->a[obj->head];
}

//获取队尾元素
int myCircularQueueRear(MyCircularQueue* obj);

int myCircularQueueRear(MyCircularQueue* obj) {
    //判空
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    //细节，这里是预防tail的下表是0时，而tail指向的是队尾的下一个位置。
    //当tail-1（0-1），数组下表为-1，越界了。
    //一个数加5再膜5这个数不变，这样处理就解决了这个问题
    int x=((obj->tail-1)+obj->k+1)%(obj->k+1);
    return obj->a[x];
}

//销毁循环队列
void myCircularQueueFree(MyCircularQueue* obj);

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}

总结

        栈和队列比较抽象，本质就是对链表和数组在一定的规则下（先进后出，先进先出）进行增删改查，对照着图来学习会更容易。

如果有错误请在评论区指出，我看到后会改正，非常感谢您的观看。