数据结构-栈和队列

栈

1.1栈和队列

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

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

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

1.2栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。

#pragma once
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;

void STInit(ST* pst);
void STDestroy(ST* pst);
void STPush(ST* pst, STDataType x);
void STPop(ST* pst);
STDataType STTop(ST* pst);
bool STEmpty(ST* pst);
int STSize(ST* pst);

void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;

	//pst->top = -1;   // top 指向栈顶数据
	pst->top = 0;   // top 指向栈顶数据的下一个位置

	pst->capacity = 0;
}

void STDestroy(ST* pst)
{
	assert(pst);

	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}

void STPush(ST* pst, STDataType x)
{
	if (pst->top == pst->capacity)
	{
		int newCapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		pst->a = tmp;
		pst->capacity = newCapacity;
	}

	pst->a[pst->top] = x;
	pst->top++;
}

void STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));

	pst->top--;
}

STDataType STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));

	return pst->a[pst->top - 1];
}

bool STEmpty(ST* pst)
{
	assert(pst);

	/*if (pst->top == 0)
	{
		return true;
	}
	else
	{
		return false;
	}*/

	return pst->top == 0;
}

int STSize(ST* pst)
{
	assert(pst);

	return pst->top;
}

队列

2.1队列的概念及结构

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

2.2队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

#pragma once

#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

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

typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int 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);
int QueueSize(Queue* pq);
bool QueueEmpty(Queue* pq);

#include"Queue.h"

void QueueInit(Queue* pq)
{
	assert(pq);

	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}

void QueueDestroy(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail\n");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;

	if (pq->ptail == NULL)
	{
		assert(pq->phead == NULL);

		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}


	pq->size++;
}

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	// 1、一个节点
	// 2、多个节点
	if (pq->phead->next == NULL)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else
	{
		// 头删
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}

	pq->size--;
}

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

	return pq->phead->data;
}

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

	return pq->ptail->data;
}

int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}

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

	/*return pq->phead == NULL
		&& pq->ptail == NULL;*/
	return pq->size == 0;
}

2.3循环队列

扩展了解一下，实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型时可以就会使用循环队列。环形队列可以使用数组实现，也可以使用循环链表实现。
 

循环队列通常使用两个指针来表示队列的头部和尾部。其中，队头指针（front）指向队列的第一个元素，队尾指针（rear）指向队列最后一个元素的下一个位置。当队列为空时，front 和 rear 指向同一个位置。

循环队列的关键操作包括入队（enqueue）和出队（dequeue）操作。入队操作将元素添加到队尾，并将队尾指针后移；出队操作删除队头元素，并将队头指针后移。如果队列已满（即队尾指针的下一个位置等于队头指针），则无法执行入队操作；如果队列为空（即队头指针和队尾指针相等），则无法执行出队操作。

为了实现循环队列的循环特性，当队列的尾部指针已经达到数组的末尾时，如果队头指针指向数组的起始位置，则将队尾指针指向数组的起始位置，从而形成循环。这样可以充分利用数组空间，提高队列的效率。

循环队列具有一些优点，包括：

• 入队和出队操作的时间复杂度都是 O(1)，即常数时间复杂度，与队列的大小无关。
• 对于固定大小的缓冲区，循环队列可以充分利用数组空间，避免了元素搬移的开销。

然而，循环队列也有一些限制和注意事项：

• 循环队列的容量是固定的，一旦创建后无法动态扩容。如果需要动态调整容量，可能需要重新创建一个更大的循环队列，并将元素从旧队列复制到新队列。
• 循环队列的容量必须是固定的缓冲区大小减一，这是为了区分队列是满还是空的条件。
• 在使用循环队列时，需要小心处理队列满和队列空的情况，避免出现错误的操作。

循环队列是一种特殊的队列，它可以在队列满时重新利用已经出队的空间。在循环队列中，我们通常需要维护一个队头指针和一个队尾指针。队头指针指向队列的第一个元素，队尾指针指向下一个插入的位置。当队尾指针到达队列的末尾并且还需要插入元素时，队尾指针会循环回到队列的开始。

一般来说，我们可以用以下方式来判断一个循环队列是否满了：

1. 保留一个元素的空间不使用，也就是说，如果队列的最大大小是N，那么我们只将队列填充到N-1个元素。这样，如果队尾指针已经到达队列末尾并且队头指针没有指向队列开头，那么我们就知道队列已经满了。
2. 使用一个额外的布尔变量来跟踪队列是否已满。当插入元素时，如果队尾指针到达队列末尾并且队头指针没有指向队列开头，那么我们就设置这个布尔变量为true。

在第一种方法中，如果队尾指针已经到达队列末尾并且队头指针没有指向队列开头，那么队列就满了。在第二种方法中，如果布尔变量为true，那么队列就满了。

这两种方法都有各自的优点和缺点。第一种方法的空间效率更高，因为它不需要额外的空间来存储布尔变量。但是，它的时间效率可能较低，因为每次插入元素时都需要检查队尾指针是否到达队列末尾。第二种方法的时间效率更高，因为它只需要检查一个布尔变量。但是，它的空间效率较低，因为它需要一个额外的布尔变量。

在计算循环队列是否满的情况下，第一种方法，也就是"保留一个元素的空间不使用"的方法，可以通过以下公式来判断：

如果 (rear + 1) % max_size == front，那么队列已满。

这里 rear 是队尾指针，front 是队头指针，max_size 是队列的最大容量。这个公式的逻辑是，如果队尾指针加一（表示新元素将要插入的位置）然后对队列的最大容量取模（考虑到循环的情况）等于队头指针，那么队列就已经满了。

请注意，这个公式假设了队列的起始位置是从0开始的，如果你的实现是从1开始的，那么公式应该稍作修改。如果从1开始，那么队尾指针和队头指针都应该在每次操作时进行加一操作，即 rear = (rear + 1) % max_size 和 front = (front + 1) % max_size，然后再判断 (rear + 1) % max_size == front。