新手向C语言实现特殊数据结构——队列

Posted 2021-10-25 燕麦冲冲冲

目录

• • 前言
  • 一、易错接口详解
  • • 1.1 出队
    • 1.2 入队
  • 二、 简单接口的实现
  • • 2.1 队列的初始化
    • 2.2 队列节点计数
    • 2.3 队列的销毁
    • 2.4 判断队列是否为空
    • 2.5 返回队头数据
    • 2.6 返回队尾数据
  • 三、头文件引用、函数与结构体定义
  • 四、拾枝杂谈
  • • 4.1 队列接口调用方式
    • 4.2 用两个队列实现栈

前言

使用单向无头不循环链表实现队列。

队列：符合先进先出逻辑的特殊数据结构。

不适合用数组来实现，虽然入队便捷但是出队时需要挪动队首后的所有元素，效率略低。

单向不循环链表对于找尾的效率确实低，但是可以在结构体中定义出队首节点和队尾节点，分别管理使得入队和出队的效率都高。所以就需要定义两个结构体，一个管理节点的内容，一个管理整个队列。

建议先跳转到第三部分阅读结构体定义的代码，以便后续便于理解。

关于改变链表头节点的方式：

1、二级指针（传指针解引用改变）

2、返回新头（接受改变值）

3、带哨兵位的头节点（本质上不会改变头节点）

4、结构体包一起（大结构体一级指针改变）

此次选择第四种方式。

可能这时候就会有同学这样问了：为什么在实现单向不循环链表的时候不把结构体包一起呢？这样不就解决了找尾效率低的问题吗？

哎，这位同学就年轻了啊。你这样解决了尾插的问题，但是能解决尾删的问题吗？单向不循环链表中时不能通过一个节点找到上一个节点的。也就是尾删了后还是要找尾···

一、易错接口详解

1.1 出队

出队算法：法一：保存下一个节点为next，再删除。

法二：保存要删除的节点为del，把头结点赋值为新节点，然后free掉del

此次选择法一。

需要注意队列为空时调用此接口会出现非法访问的错误，所以需要提前断言报错。

这里把判断是否为空的功能封装成一个函数，详情请跳转至第二部分查看。

特殊情况：当链表删除掉最后一个节点时，ptail会成为野指针。

所以仅有一个节点时就直接free掉，再将头指针和尾指针都赋值为NULL。

正常情况下，出队时记得保留队头节点的下一节点的地址，以便头节点迭代。

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	if (pq->phead->next == NULL)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else
	{
		QueueNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}
}

1.2 入队

入队算法：为新的头节点开辟新空间，并插入有效数据。之后的步骤相当于链表的尾插。

但是需要注意特殊情况：队列中没有节点时需要直接把头尾节点都改为新节点。

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		printf("malloc fail\\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	//新节点初始化结束
	if (pq->ptail == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
}

二、 简单接口的实现

2.1 队列的初始化

算法：将头指针和尾指针都赋值为NULL

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
}

2.2 队列节点计数

int QueueSize(Queue* pq)
{
	assert(pq);
	int count = 0;
	QueueNode* cur = pq->phead;
	while (cur)
	{
		count++;
		cur = cur->next;
	}
	return count;
}

关于链表计数的接口，如果调用频繁的话就可以在大结构体Queue中加入一个计数成员，入队或出队时修改。如果调用不频繁，就直接在接口中进行计算。

2.3 队列的销毁

算法：利用创建的新指针cur从头走到尾，走到一个节点就删除一个节点，在删除前还需要保留cur指针的下一个节点地址，以便cur指针迭代。最后还不要忘了将头节点的指针phead和为节点的指针ptail指向NULL。

void QueueDestory(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->phead;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->phead = pq->ptail = NULL;
}

2.4 判断队列是否为空

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->phead == NULL && pq->ptail == NULL;
}

2.5 返回队头数据

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->phead->data;
}

2.6 返回队尾数据

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->ptail->data;
}

三、头文件引用、函数与结构体定义

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

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

typedef struct Queue
{
	QueueNode* phead;
	QueueNode* ptail;
}Queue;

void QueueInit(Queue* pq);
void QueueDestory(Queue* pq);
void QueuePush(Queue* pq, QDataType x); 
void QueuePop(Queue* pq);                
int QueueSize(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);

四、拾枝杂谈

4.1 队列接口调用方式

首先创建一个大结构体Queue的对象q，再把对象初始化，再入队，打印的时候必须打印一个队首元素就将队首元素进行出队，直至队列为NULL时即可将队中所有元素打印完成，最终销毁整个队列，避免内存泄漏。

void Test2()
{
	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);
	}
	QueueDestory(&q);
}

4.2 用两个队列实现栈

队列的特点：先进先出

栈的特点：后进先出

算法总结如下：

1、两个队列一个有数据，另外一个为空。

2、入栈时，向不为空的队列中添加数据。

3、出栈时，将有数据的队列中的size - 1个数据导入到为空的队列，把剩下的一个数据出队——即可实现“出栈”。

由于c语言不能像C++那样使用栈的库函数，所以以下代码利用了上文中已经实现好的接口。

首先是定义一个代表栈的结构体，里面的成员为两个队列。

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

接下来实现创建栈的接口，需要注意不可在此接口中利用临时变量返回所创建栈的地址，因为临时变量会在函数调用结束时销毁，故利用动态开辟内存函数malloc开辟一个栈结构体的对象，再调用已定义好的队列初始化接口将其内部的两个队列进行初始化。

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

入栈的实现：其本质是入队，但是入队时需要保证向不为空的队列中添加数据，这时候QueueEmpty接口可以帮助快速判断哪一个为空队。

这时候有同学可能会问为啥“入栈”的时候非要往不为空的队列里面加数据呢？

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

出栈的实现：将非空队列的size - 1个元素都入队到另一个队列中，再删除剩下的一个元素。

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

取栈顶元素：相当于返回非空队列的队尾元素，直接调用已经实现好的接口即可。

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

判断栈是否为空：只需要判断两个队列是否同时为空即可。

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

销毁栈：调用已有接口分别将两个队列销毁，再释放掉表示栈的结构体对象的空间。

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