栈和队列的基本操作

一.栈

1.栈的结构

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

        栈就像往一个木桶里面塞东西.要拿到最开始塞的东西,就得将后塞的东西先出.栈是一个先入后出的数据结构,你只能在顶部放置或移除，而不能在中间或底部操作。这使得栈非常适合处理需要按照相反顺序处理的数据，例如函数调用、表达式求值、括号匹配等应用场景。

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

2.栈的操作

1.初始化

void StackInit(Stack* ps)
{
	assert(ps);
	STDataType* arr = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (arr == NULL)
	{
		perror("malloc;");
		exit(-1);
	}
	ps->arr = arr;
	ps->capacity = 4;
	ps->top = -1;
}

我们这里实现了一个数组栈.刚开始容量为4.栈顶指针指向栈顶元素

2.销毁

void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->arr);
	ps->arr = NULL;
	ps->capacity = 0;
	ps->top = -1;
}

释放arr数组,并清空容量和栈顶指针

3.入栈

void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	if (ps->top+1 == ps->capacity)
	{
		int newcapactily = ps->capacity + 2;
		STDataType* newarr = (STDataType*)realloc(ps->arr, sizeof(STDataType) * newcapactily);
		if (newarr == NULL)
		{
			perror("malloc;");
			return;
		}
		ps->arr = newarr;
		ps->capacity = newcapactily;
	}
	ps->arr[++ps->top] = data;
}

如果栈满即扩容.向栈顶插入

4.出栈

void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->top > -1);
	ps->top--;
}

栈顶指针减一即可,注意栈空时不能Pop

5.获取栈顶元素

STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->top > -1);
	return ps->arr[ps->top];
}

6.判断栈为空

int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top == -1;
}

7.获取栈里元素个数

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}

二.队列

1.队列的结构

        队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 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;

队列可以用数组或链表实现，具体的实现方式取决于应用场景和性能需求。在计算机科学中，队列常用于管理任务、缓存数据、事件处理等方面。

2.队列的操作

1.初始化

void QueueInit(Queue* q)
{
	assert(q);
	q->front = q->rear = NULL;
	q->size = 0;
}

我们这里实现的是一个链式队列,front和rear为队列的队头和队尾,size为队中数据个数

2.销毁

void QueueDestroy(Queue* q)
{
	assert(q);
	while (!QueueEmpty(q))
	{
		QueuePop(q);
	}
	q->front = q->rear = NULL;
}

将队中所有元素Pop,将头尾指针置为NULL

3.入队

void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* node = (QNode*)malloc(sizeof(QNode));
	if (node == NULL)
	{
		perror("malloc;");
		return;
	}
	node->data = data;
	node->next = NULL;
	if (q->front == NULL)
	{
		q->front = node;
		q->rear = node;
	}
	else
	{
		q->rear->next = node;
		q->rear = node;
	}
	q->size++;
}

向队尾插入数据,如果队头和队尾为NULL,就将队头和队尾都指向这个节点,反之则只更新队尾指针,

4.出队

void QueuePop(Queue* q)
{
	assert(q);
	assert(q->front);
	QNode* p = q->front->next;
	free(q->front);
	q->front = p;
	p = NULL;
	if (q->front == NULL)
	{
		q->rear = NULL;
	}
	q->size--;
}

更新队头指针即可,如果队头为空,就将队尾也置为空

5.获取队头元素

QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(q->front);
	return q->front->data;
}

6.获取队尾元素

QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(q->rear);
	return q->rear->data;
}

7.判断队为空

int QueueEmpty(Queue* q)
{
	assert(q);
	return q->size == 0;
}

8.返回队中元素个数

int QueueSize(Queue* q)
{
	assert(q);
	return q->size;
}