我已经尽力在讲明白《栈和队列》了，你可以去看录像！

目录

一、栈

1.栈的概念和结构 

 2.栈的实现

（1）定义栈的结构体

（2）初始化

（3）压栈

（4）判空

（5）出栈

（6）返回栈顶元素

（7）返回栈有效元素个数

（8）销毁

3.有关栈值得注意的问题

二、队列

1.队列的概念和结构

 2.队列的实现

 (1)定义队列的结构体

（2）队列其余操作

（3）队列实现过程应注意的问题

 三、栈和队列之间的联系

1.用栈实现队列

（1）原理：

（2）具体代码：

2.用队列实现栈

（1）原理

 （2）具体代码：

四、循环队列

1.概念

 2.作用

3.注意事项

4.具体代码：

---

        今天要跟大家介绍的另外两种非常重要的数据结构--栈和队列，栈和队列是特点针锋相对的两个数据结构，但是有意思的是它们同时还能够相互联系，比如我们可以用两个栈实现队列操作，用两个队列实现栈操作等，当然首先我们得了解它们的基础性质特点。

一、栈

1.栈的概念和结构 

---

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

        栈是限定仅在表尾进行插入或删除操作的线性表。因此对栈来说，表尾端有其特殊含义，称为栈顶。相应的表头端称为栈底。栈的特点是后进先出，即最后被压入栈的元素会第一个被弹出。因此，栈有重要的两个操作：压栈和出栈。

• 压栈：栈的插入操作，入数据在栈顶。
• 出栈：栈的删除操作，出数据也在栈顶。

 

 2.栈的实现

---

        对于栈的实现来说既可以使用数组，也可以使用链表。因为对于栈的两个重要操作——压栈和出栈来说，只需要对数组或链表进行尾插或者尾删。相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。

         写出一个能够正常使用栈，首先需要定义好栈的结构体，然后满足数据结构最基本的增删查改的操作。对于栈来说，需要有压栈、出栈、返回栈顶元素、返回栈中有效元素个数、检测栈是否为空、栈的销毁这些功能。即下图：

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);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps);
// 销毁栈
void StackDestroy(Stack* ps);

接下来让我们用具体的代码实现下列功能。 

（1）定义栈的结构体

        下面是定长的静态栈的结构，实际中不实用，所以我们主要实现下面支持动态增长的栈。

typedef int STDataType;
#define N 10
typedef struct Stack
{
    STDataType a[N];
    int _top; // 栈顶
}Stack;

         常用的是支持动态增长的栈。

typedef int STDataType;
typedef struct Stack
{
    STDataType* a;
    int top; // 栈顶
    int capacity; // 容量
}Stack;

（2）初始化

void StackInit(ST* ps)
{
	assert(ps);
	//初始化
	ps->a = NULL;
	ps->top = 0;
	ps->capacicy = 0;
}

（3）压栈

void StackPush(ST* ps, STDataType x)
{
    assert(ps);
	//检查空间，空间满了需要增容。
	if (ps->top == ps->capacity)
	{
        //栈为空，则第一次开辟4个所需类型的空间
        //栈满且不为空，则扩容2倍
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		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[ps->top] = x;
	ps->top++;
}

（4）判空

        因为接下来的出栈和返回栈顶元素操作需要检测栈是否为空，所以我们先实现判空功能。

bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

（5）出栈

        出栈前需要先判断栈是否为空，如果栈为空则不能删除，使用assert报错。

void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	
	--ps->top;
}

（6）返回栈顶元素

        同理，栈为空无法返回，如果为空直接断言。

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	
	return ps->a[ps->top - 1];
}

（7）返回栈有效元素个数

int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;
}

（8）销毁

void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

3.有关栈值得注意的问题

---

1. 使用数组定义支持动态增长的栈时，或者使用链表定义栈时，在进行销毁操作，不要忘记数组和链表中的每个节点是由malloc函数动态开辟的，销毁栈时不要忘记同时需要销毁动态开辟的数组和节点，防止出现内存泄漏。
2. 数据结构建议不要直接访问结构体数据，一定要通过函数接口访问！                                       例如：如果想要判断栈是否为空，应该使用定义的StackEmpty函数，不可以直接访问st->top然后自行判断，因为每个人实现栈的细节可能稍微有些差异，直接访问结构体数据会导致出现错误
3. 数据结构讲究低耦合高内聚，无论使用什么方式实现的栈，只要功能符合要求即可。栈的实现方式最好足够独立，与后面的使用过程相互独立互不影响。
4. 其他问题欢迎补充交流。

---

二、队列

1.队列的概念和结构

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

 

 2.队列的实现

        队列也可以数组和链表的结构实现，但与栈相比队列需要头删的操作，所以使用链表的结构实现更优一些，如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

         写出一个能够正常使用队列，与栈的实现过程基本相同，首先需要定义好队列的结构体，然后满足数据结构最基本的增删查改的操作。对于队列来说，需要有初始化队列、队尾入队列、队头出队列、获取队列头部元素、获取队列尾部元素、获取队列中有效元素个数、检测队列是否为空、队列的销毁。即下图：

// 链式结构：表示队列
typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;

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

 (1)定义队列的结构体

因为这里我们使用链表实现队列，首先应该定义好每一个节点的结构体。同时队列需要进行头删，尾插，尾删的操作，因此队列的结构体定义head和taill两个结构体指针方便操作

typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

（2）队列其余操作

因为队列和栈的操作类似，下面直接给出全部代码

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");
		exit(-1);
	}
	else
	{
		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);
	assert(!QueueEmpty(pq));

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* del = pq->head;
		pq->head = pq->head->next;

		free(del);
		del = NULL;
	}

	pq->size--;
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->head == NULL && pq->tail == NULL;
}

int QueueSize(Queue* pq)
{
	assert(pq);
	/*QNode* cur = pq->head;
	int n = 0;
	while (cur)
	{
		++n;
		cur = cur->next;
	}

	return n;*/
	return pq->size;
}

（3）队列实现过程应注意的问题

1. 进行队尾入队列操作时，每次应该使用malloc等动态内存开辟函数开辟新的节点。
2. 销毁队列时与栈相同，不要忘记销毁由动态内存开辟函数开辟出的空间，防止出现内存泄漏，销毁完之后再销毁队列。
3. 进行返回队列有效元素个数，判断队列是否为空等操作时与栈相同，不要直接访问结构体数据，一定要通过函数接口访问。  
4. 进行队头出队列、获取队列头部元素、获取队列尾部元素等操作时，应该注意判断队列是否为空，防止出现错误。判断时可以直接使用自己定义的QueueEmpty函数，这里再次强调第三条的重要性：数据结构一定要通过函数接口访问！
5. 其他问题欢迎补充。

---

 三、栈和队列之间的联系

正如我开头所说，栈和队列之间相互联系，可以互相实现。下面让我借用两道oj题来简单解释一下栈和队列的联系。

1.用栈实现队列

请各位先看一看这道题目，自己先动脑思考片刻之后再看我的文章。

https://leetcode.cn/problems/implement-queue-using-stacks/

以下三点解释较为复杂，可以先看图，再回过头来看。

（1）原理：

• 我们通过一个具体的例子来分析往该队列插入和删除元素的过程。首先插入一个元素 a ，我们把它插入 stack1 ，此时 stack1 中的元素有 {a} ，stack2 为空。再压入两个元素 b 和 c ，还是插入 stack1 ，此时 stack1 中的元素有 {a,b,c} ，其中 c 位于栈顶，而 stack2 任然是空的。
• 这个时候我们试着从队列中删除一个元素。按照队列先入先出的规则，由于 a 比 b 、c 先插入队列中，最先被删除的元素应该是 a 。元素 a 存储在 stack1 中但并不在栈顶上，因此不能直接进行删除。注意到 stack2 一直没有被使用过，现在是让 stack2 发挥作用的时候了。如果我们把 stack1 中的元素逐个弹出并压入 stack2，则元素在 stack2 中的顺序正好和原来在 stack1 中的顺序相反，但是却和正常入队列的顺序相同了。因此经过 3 次弹出 stack1 和压入 stack2 的操作之后， stack1 为空， 而 stack2 中的元素是 {c,b,a}，这时候就可以弹出 stack2 的栈顶 a 了。
• 从上面的分析中我们可以总结出删除一个元素的步骤：当 stack2 不为空时，在 stack2 中的栈顶元素是最先进入队列的元素，可以弹出。当 stack2 为空时，我们把 stack1 中的元素逐个弹出并压入 stack2 。由于先进入队列的元素被压倒 stack1 的低端，经过弹出和压入操作后就处于 stack2 的顶端，又可以直接弹出。

以上分析解释来自于《剑指offer》，简而言之，用两个栈就可以实现队列的功能。首先定义两个栈pushST和popST，pushST用来入队，popST用来出队。将数据压栈到pushST，pushST出栈，出栈的数据再压栈到popST，即可得到原本是队列形式的顺序了。

（2）具体代码：

明白原理之后，代码实现非常简单，读者自己写代码时一定要注意画图，理清思路后再写代码 ，

可以有效减少bug，同时也方便调试

typedef struct {
    ST pushST;
    ST popST;
} MyQueue;

MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&obj->pushST);
    StackInit(&obj->popST);
    return obj;
}
void pushST_to_popST(MyQueue* obj)
{
    if(StackEmpty(&obj->popST))
    {
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
}

void myQueuePush(MyQueue* obj, int x) {
    pushST_to_popST(obj);
    StackPush(&obj->pushST,x);
}

int myQueuePop(MyQueue* obj) {
    pushST_to_popST(obj);
    int top = StackTop(&obj->popST);
    StackPop(&obj->popST);
    return top;
}

int myQueuePeek(MyQueue* obj) {
    pushST_to_popST(obj);
    int top = StackTop(&obj->popST);
    return top;
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->pushST)&&StackEmpty(&obj->popST);
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->pushST);
    StackDestroy(&obj->popST);
    free(obj);
    obj=NULL;
}

2.用队列实现栈

https://leetcode.cn/classic/problems/implement-stack-using-queues/description/

（1）原理

为了满足栈的特性，即最后入栈的元素最先出栈，在使用队列实现栈时，应满足队列前端的元素是最后入栈的元素。可以使用两个队列实现栈的操作。首先，需要A,B两个队列：

• 入栈：对 A 进行入队列
• 出栈：将A中元素加入到B中，当A中就剩一个数据时，出队列即出栈，再交换AB两队列；
• 取栈顶元素：和出栈过程相似，在将A中最后一个元素，记录下来，再入B队列，再交换AB两队列，记录下来的数据就是栈顶元素；

因此，两个队列中始终有一个队列是空，因此定义时可以用empty和nonempty区分。

 

 （2）具体代码：

typedef struct {
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);
    
    return obj;
}

void myStackPush(MyStack* obj, int x) {
    if( !QueueEmpty(&obj->q1) )
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
    
}

int myStackPop(MyStack* obj) {
    Queue* empty = &obj->q1;
    Queue* nonempty = &obj->q2;
    if( !QueueEmpty(&obj->q1) )
    {
        empty = &obj->q2;
        nonempty = &obj->q1;
    }
    
    while( QueueSize(nonempty) > 1 )
    {
        QueuePush( empty, QueueFront(nonempty) );
        QueuePop(nonempty);
    }
    
    int top=QueueFront(nonempty);
    QueuePop(nonempty);
    return top;
}

int myStackTop(MyStack* obj) {
    if( !QueueEmpty(&obj->q1) )
    {
        int top=QueueBack(&obj->q1);
        return top;
    }
    else
    {
        int top=QueueBack(&obj->q2);
        return top;
    }
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
    obj = NULL;
}

---

四、循环队列

1.概念

        循环队列属于队列的一种，由于循环队列实现难度较大，因为我在这里单独提出，并且目前只说明用数组实现循环队列，链表方式欢迎大佬指导。

        可以想象一下，假如我们使用通常的数组。那么在使用过程中，我们是从后面加入数据，从前面移除数据。那么随着出队和入队的进行，数组会整体向右平移，因为数组前面的元素因为出队变成了空白，变得不可使用。造成空间的浪费。如果每出队一次，都将数组向左平移一次，又会很麻烦，造成时间上的浪费。综上，我们使用循环队列，就是将队首和队尾黏在一起。

 2.作用

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

3.注意事项

按照常规队列的实现方法，我们如果采用数组的方式实现，需要有front和back头尾两个指针，front指向队头，back指向队尾的下一个位置。

但是这种实现方式存在一个弊端：无法区分满和空的状态。

对此，我们有两种解决方式：1.加一个size 2.增加一个空间，满的时候永远留一个空位置。

4.具体代码：

typedef struct {
    int* a;
    int front;
    int rear;
    int N;
} MyCircularQueue;

bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (int*)malloc(sizeof(int)*(k+1));
    obj->front = obj->rear = 0;
    obj->N = k+1;
    return obj;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if( myCircularQueueIsFull(obj) )
        return false;
    obj->a[obj->rear] = value;
    obj->rear++;
    
    //控制如果到空间尾之后，rear回到0的位置
    obj->rear %= obj->N;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if( myCircularQueueIsEmpty(obj) )
        return false;
    obj->front++;
    //控制如果到空间尾之后，rear回到0的位置
    obj->front %= obj->N;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if( myCircularQueueIsEmpty(obj) )
        return -1;
    return obj->a[obj->front];

}

int myCircularQueueRear(MyCircularQueue* obj) {
    if( myCircularQueueIsEmpty(obj) )
        return -1;
    return obj->a[(obj->rear-1+ obj->N)%obj->N];
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front == obj->rear;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->rear+1)%obj->N == obj->front;
    
}

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

 

---

注意：此文章是个人理解，若是其中有错误或者不足，还希望各位朋友进行指导。