栈、队列和循环队列

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端 称为栈顶，另一端称为栈底。

栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

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

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

压栈和出栈都是栈的两个操作，但是要注意的是，栈的操作是只可以在栈顶的位置进行，可以想象成只有一个口的容器，只能从这一个口进和出，因此需要遵顼先进后出的原则。

关于栈的 C 语言实现，我们需要注意的是，可以使用顺序表实现也可以使用链表实现，每一种不同的实现方式也都有各自的优劣，虽然C++种有封装好的可以直接调用的库我们不需要手动写，但是C语言的实现可以帮助我们更好的理解栈这样的结构。

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

上面就是栈的结构体实现，我们可以看到这里我们使用的是顺序表的方式实现一个栈，由于栈的操作只可以在栈顶的位置，所以我们需要定义一个栈顶的指针，这里使用的一个整型的top，用来标记数组的下标。

栈的一些实现如下

void STInit(ST* pst);//初始化栈
void STDestroy(ST* pst);//销毁栈

void STPush(ST* pst, STDataType x);//入栈
void STPop(ST* pst);//出栈

STDataType STTop(ST* pst);//栈顶元素
int STSize(ST* pst);//栈中有效元素个数
bool STEmpty(ST* pst);//栈是否为空


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

	pst->a = NULL;
	pst->capacity = 0;
	pst->top = -1;
}

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

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

void STPush(ST* pst, STDataType x)
{
	assert(pst);

	if (pst->top+1 == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	}

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

void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top > -1);

	pst->top--;
}

STDataType STTop(ST* pst)
{
	assert(pst);
	assert(pst->top > -1);

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

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

	return pst->top + 1;
}

bool STEmpty(ST* pst)
{
	assert(pst);
	
	return pst->top == -1;
}

int main()
{
	ST s;
	STInit(&s);
	STPush(&s, 1);
	STPush(&s, 2);
	STPush(&s, 3);
	while (!STEmpty(&s))
	{
		printf("%d ", STTop(&s));
		STPop(&s);
	}
	printf("\n");

	return 0;
}

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

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

typedef int QDataType;
//链式结构实现队列--单链表
typedef struct QListNode
{
	//定义队列节点
	QDataType data;
	struct QListNode* next;
}QNode;

typedef struct Queue
{
	//定义队列规则
	QNode* front;
	QNode* rear;
	int size;
}Queue;

可以看到，我们定义首先定义链表的节点，然后在定义队列的结构，这样的方式避免了一些代码的复杂写法，如果我们在外部定义，那么传递参数的时候就需要传递指针的地址，否则无法对队列进行改变。

下面是队列的一些实现

void QueueInit(Queue* q);
//结构体指针即可修改成员内容
//void QueueInit(QNode** front,QNode** rear);
//定义的时候是定义一个指针，想要修改指针就需要传指针的地址，所以需要二级指针


void QueueDestroy(Queue* q);
void QueuePush(Queue* q, QDataType x);
void QueuePop(Queue* q);

QDataType QueueFront(Queue* q);
QDataType QueueBack(Queue* q);

int QueueSize(Queue* q);
bool QueueEmpty(Queue* q);


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

	q->front = q->rear = NULL;
	q->size = 0;
}

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

	QNode* cur = q->front;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

	q->front = q->rear = NULL;
	q->size = 0;
}

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

	QNode* newnode = (QNode*)malloc(sizeof(QNode));

	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}

	newnode->data = x;
	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);
	q->size--;
	del = NULL;

	if (q->front == NULL)
	{
		q->rear = NULL;
	}
}

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;
}
bool QueueEmpty(Queue* q)
{
	assert(q);

	return q->front == NULL;
}

int main()
{
	Queue q;
	QueueInit(&q);

	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}

	QueueDestroy(&q);
	return 0;
}

在实现普通队列的时候我们采用的是链式结构，那么还有一种队列是比较特殊的，那就是循环队列

https://leetcode.cn/problems/design-circular-queue/这里放上力扣的一道题，就是实现循环队列，这咋恶道题中，我们实现队列的方式采用了数组的形式。上代码！

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


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

    return obj;
}

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

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

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->rear] = value;
    obj->rear++;
    obj->rear %= (obj->k+1);

    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->front++;
    obj->front %= (obj->k+1);
    
    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->k+1)%(obj->k+1)];
}

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