数据结构队列的实现与简单应用

Posted 2021-09-09 蓝乐

队列

• 队列的概念及结构
• 队列的实现
• • 队列的链式结构
  • 队列的基本操作
• 队列的简单应用

队列的概念及结构

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

队列的实现

作为线性结构，队列同样可以用顺序表和链表的结构实现，但是使用链表的结构会更优一些，这是因为队列需要不断的进行头插的操作，如果使用数组的话会大大增加操作的时间复杂度，从而使效率降低。

队列的链式结构

实现队列首先用一个结构体实现队列的结点，由于队列需要频繁对头部和尾部进行操作，因此再使用一个结构体包含队列的头结点和尾节点，从而使操作更加便捷。

typedef int QDataType;

typedef struct QueueNode//队列结点
{
	QDataType data;//数据域
	struct QueueNode* next;//指针域
}QueueNode;

typedef struct Queue//包含队列的头尾
{
	QueueNode* front;//队头
	QueueNode* rear;//队尾
}Queue;

队列的基本操作

1.初始化队列
队列的初始化只需将队列的两个指针都置空即可：

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

	pq->front = pq->rear = NULL;
}

2.入队操作
将原先的rear指针指向新结点，再让新结点成为新的rear指针，需要注意队列为空的情况

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));//生成一个新结点
	if (newnode == NULL)
	{
		perror("QueInit");
		exit(-1);
	}
	newnode->next = NULL;
	newnode->data = x;
	if (QueueEmpty(pq))//队列为空
	{
        pq->front = pq->rear = newnode;
	}
	else
	{
		pq->rear->next = newnode;
		pq->rear = newnode;
	}
}

3.出队操作
将原先的front指针赋给其下一个结点，再将原队头结点free掉即可，注意队列为空的情况，还有队列只有一个结点时需要考虑rear指针。

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));//队列非空
	if (pq->front == pq->rear)//队列只有一个结点
	{
		free(pq->front);
		pq->front = pq->rear = NULL;
	}
	else
	{
		QueueNode* next = pq->front->next;
		free(pq->front);
		pq->front = next;
	}
}

4.读取队列头部元素

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

5.读取队列尾部元素

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

6.获取队列有效元素个数
对于该函数，如果需要频繁调用的话，则可以再原队列结点的结构体中增加一个size变量来记录队列有效元素个数。

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

7.检测队列是否为空
队列为空则返回真，非空则返回假

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

8.销毁队列
将队列的所有结点free

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->front;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->front = pq->rear = NULL;
}

队列的简单应用

实际中我们还会用到一种队列叫循环队列，这种环形队列可以使用数组实现，也可以使用循环链表实现。
这里我们用一个题目来介绍循环队列。
设计循环队列
设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
leetcode链接

在本题中由于使用链表需要不停地生成和销毁结点，操作繁琐，因此使用顺序表来实现会较为简单。

typedef struct {
    int* a;
    int front;//队头指针
    int rear;//队尾指针
    int k;//队列长度
} MyCircularQueue;


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

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

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

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    assert(obj);
    if(myCircularQueueIsFull(obj))//队列已满
    return false;
    else
    {
        obj->a[obj->rear] = value;
        obj->rear = (obj->rear + 1) % (obj->k + 1);
        return true;
    }
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
    return false;
    else
    {
        obj->front = (obj->front + 1) % (obj->k + 1);
        return true;
    }
}

int myCircularQueueFront(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
    return -1;
    else
    return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
    return -1;
    if(obj->rear == 0)
    return obj->a[obj->k];
    else
    return obj->a[obj->rear - 1];
}

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