栈与队列的实现_队首怎么求-CSDN博客

本文链接：https://blog.csdn.net/bhbca/article/details/127855779

今日目标：

栈的实现
队列的实现

栈和队列的实现方法不唯一，以下栈和队列的接口都是参考c++种STL的实现。

1.栈

1.1 栈的概念

栈是一种特殊的线性表，只允许在一端进行插入，删除操作，进行操作的一端是栈顶，另一端是栈底。栈中的元素遵守"后入先出"的原则，即：LIFO（last in first out）;

1.2 栈的结构图示

1.3物理存储结构

物理存储结构分为：

顺序存储：即数组
链式存储：即链表

栈要求在一端进行插入，删除。考虑到效率的因素，应该选择有一端插入删除效率高的存储结构。对于数组：尾插，尾删效率高；对于链表：头插，头删效率高。那么两者皆可取，但是细细比较下，还是数组更优些，具体原因还需写出两者比较。下面实现数组栈；
存储栈需要的类型：选择数组尾作为栈顶

typedef int STDataType;     //便于修改存储的数据类型
typedef struct stack
{
	STDataType* data;
	int top;            //代表栈顶元素的下一个下标，即元素个数
	int capacity;       
}stack;
int main(void)
{
    stack st;
    //....操作
    return 0;
}

1.4常见的接口

void StackInit(stack *ps); -初始化
void StackDestroy(stack* ps); -销毁
void StackPush(stack* ps, STDataType x); -入栈
void StackPop(stack* ps); -出栈
STDataType StackTop(stack* ps); -求栈顶元素
bool StackEmpty(stack* ps); -判断栈是否空
int StackSize(stack* ps); -求栈长

1.3.1初始化

初始化时可以给数组分配空间，也可以不分配。一定要初始化top和capacity。当top初始化为-1时，top指向的是栈顶元素，当top初始化为0时，top指向的是栈顶元素的下一个。

void StackInit(stack* ps)
{
	assert(ps != NULL);

	ps->data = NULL;
	//ps->data = (STDataType*)malloc(sizeof(STDataType) * 4);  //分配四个空间
	//ps->capacity = 4;
	ps->top = 0;
	ps->capacity = 0;
}

1.3.2销毁

将top和capacity置为0，要释放数组，同时将其置为NULL

void StackDestroy(stack* ps)
{
	assert(ps != NULL);

	free(ps->data);
	ps->data = NULL;   //一定要置空，防止野指针的出现
	ps->top = 0;
	ps->capacity = 0;
}

1.3.3入栈

入栈前需要检查是否需要扩容。此时的扩容并不需要包装成一个函数，这里只有入栈才会使用他。只有当代码多次重复出现时，才会考虑是否需要包装为函数。

void StackPush(stack* ps, STDataType x)
{
	assert(ps != NULL);
	//当top初始化为-1时，需要判断top+1=capacity
	//此时top初识化为0，判断是否需要扩容，
	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		STDataType* temp = (STDataType*)realloc(ps->data, \
                                                sizeof(STDataType) * newCapacity);
		if (temp == NULL)
		{
			perror("realloc::Push");
			exit(-1);
		}

		ps->data = temp;
		ps->capacity = newCapacity;
	}
	ps->data[ps->top++] = x;
}

1.3.4出栈

出栈需要检查栈是否为空,可以先移步到判空接口。

void StackPop(stack* ps)
{
	assert(ps != NULL);

	//判断栈是否为空
	assert(!StackEmpty(ps));

	ps->top--;
}

1.3.5求栈顶元素

仍然需要判空

STDataType StackTop(stack* ps)
{
	assert(ps != NULL);
	assert(!StackEmpty(ps));
	//当栈初始化为-1时，并不是如此
	return ps->data[ps->top - 1];
}

1.3.6判空

如果栈空返回真。由于c语言中c99才出现布尔类型，所以需要引头文件，stdbool.h

bool StackEmpty(stack* ps)
{
	assert(ps != NULL);

	return ps->top == 0;
}

1.3.7求栈长

int StackSize(stack* ps)
{
	assert(ps != NULL);

	return ps->top;
}

1.5栈接口的使用

int main(void)
{
	stack st;
	StackInit(&st);

	StackPush(&st, 3);
	StackPush(&st, 2);
	StackPush(&st, 1);
	printf("%d\n" ,StackSize(&st));
	
	if (!StackEmpty(&st))
	{
		printf("%d\n", StackTop(&st));
		StackPop(&st);
		printf("%d\n", StackSize(&st));

	}
	StackDestroy(&st);
	return 0;
}

2.队列

2.1队列的概念

队列是一种特殊线性表，它只允许在一端进行插入操作，另一端进行删除操作。插入的一端叫做队尾，删除的一端叫做队首。队列中元素遵循“先进先出”的原则。即：FIFO(first in first out);

2.2队列的结构图示

2.3物理存储结构

  由于队列是一端进行插入，一端进行删除。如果用数组的话，始终有一端的时间复杂度为：O(n)，但是如果用链表的话，只需要加一个尾指针，就可以实现，尾插为O(1),头删为O(1)。所以选择链表较好。<br />由于此时额外增加了一个尾指针，所以一共需要两个指针来管理这个队列(头，尾),通过c语言的学习，我们知道这种情况最好使用结构体封装起来。

:::tips
前面实现链表，我们只需要一个头指针就可完成操作，所以没有封装为结构体
:::

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

typedef struct Queue
{
	QNode* head;
	QNode* tail;
    //size为数据个数，后面解释这个size的作用，先不用管
	int size;
}Queue;
int main(void)
{
    Queue q;
    //....操作
    return 0;
}

2.4常见的接口

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); -求队尾元素
bool QueueEmpty(Queue* pq); -判空
int QueueSize(Queue* pq); -求队长

2.4.1初始化

void QueueInit(Queue* pq)
{
	assert(pq != NULL);

	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

2.4.2销毁

一个一个释放，最后还要置NULL，防止野指针的出现

void QueueDestroy(Queue* pq)
{
	assert(pq != NULL);

	QNode* cur = pq->head;
	while (cur != NULL)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}

2.4.3入队

入队就是链表中的尾插操作，需要检查队列是否为空，

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

    //构造一个新节点
	QNode* newNode = (QNode*)malloc(sizeof(QNode));
	if (newNode == NULL)
	{
		perror("malloc::");
		exit(-1);
	}
	newNode->data = x;
	newNode->next = NULL;

    
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newNode;
	}
	else
	{
		pq->tail->next = newNode;
		pq->tail = newNode;
	}
    //队列元素+1
	pq->size++;
}

2.4.4出队

出队前需要检查队列是否为空，

一定要释放，否则会内存泄漏，
当队列中只有一个元素时，头指针等于尾指针，把尾指针释放，但是头指针还指向空间，就造成了野指针

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

	QNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
	//当只有一个节点，防止野指针
	if (pq->head == NULL);
	{
		pq->tail = NULL;
	}
	pq->size--;
}

2.4.5求队首元素

需要检查队列是否为空

QDataType QueueFront(Queue* pq)
{
	assert(pq != NULL);

	assert(!QueueEmpty(pq));

	return pq->head->data;
}

2.4.6求队尾元素

与求队首元素一致，都需要检查队列是否为空

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

	return pq->tail->data;
}

2.4.7求队列长度

试想：如果没有size，怎么求队列的长度？是不是只有设置计数器，然后遍历队列，这样的话时间复杂度就为O(n),所以我们选择定义一个size来，以空间换取时间。

int QueueSize(Queue* pq)
{
	assert(pq != NULL);
	
	return pq->size;
}

2.4.8判空

有两种方法：

size = 0
head = NULL

bool QueueEmpty(Queue* pq)
{
	assert(pq != NULL);

    //return pq->head == NULL;
	return pq->size == 0;
}

2.5接口的使用

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

	QueuePush(&q, 2);
	QueuePush(&q, 3);

	printf("%d\n", QueueSize(&q));

	if (!QueueEmpty(&q))
	{
		printf("%d\n", QueueFront(&q));
		QueuePop(&q);
		
		printf("%d\n", QueueSize(&q));
	}
	QueueDestroy(&q);
	return 0;
}