队列的实现

是小刘同学啦

已于 2023-07-13 02:45:45 修改

阅读量1.8k

点赞数 85

分类专栏：笔记初阶数据结构文章标签：数据结构 c语言

于 2023-07-09 04:04:14 首次发布

本文链接：https://blog.csdn.net/m0_57388581/article/details/131566023

版权

笔记同时被 2 个专栏收录

52 篇文章 4 订阅

订阅专栏

初阶数据结构

14 篇文章 3 订阅

订阅专栏

文章详细介绍了队列的概念，包括它的FIFO特性、入队和出队操作。队列可以使用数组或链表实现，其中链表实现更优，因为它能有效处理头删和尾插操作。文章还提供了队列的C语言实现，并探讨了队列和栈的使用场景，如括号匹配和广度优先遍历。此外，文章展示了如何用队列和栈互相实现，以及设计循环队列的方法。

摘要由CSDN通过智能技术生成

多爱自己一点！

一、队列的概念以及结构

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

栈的使用场景：括号匹配、逆波兰表达式求解等的一些问题。还有把递归改为非递归（第一种方法，循环；第二种方法：栈）

队列的使用场景：公平排队；广度优先遍历；抽号机；

二、队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。涉及头删、尾插。所以可以用单链表。但是尾插又需要遍历单链表，可以用一个尾指针来解决这个问题。

Queue.h

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


typedef int QDataType;

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

typedef struct Queue
{
	QNode* head;
	QNode* tail;
}Queue;

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

Queue.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "queue.h"

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}
void QueueDestory(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
}
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	assert(newnode);
	newnode->next = NULL;
	newnode->data = x;
	if (pq->tail == NULL)//链表为空的情况
	{
		assert(pq->head == NULL);//双重保证链表为空
		pq->head = pq->tail = newnode;
	}
	else
	{
		QNode* prev = pq->tail;
		prev->next = newnode;
		pq->tail = newnode;
	}
}
//错误删除代码
//void QueuePop(Queue* pq)
//{
//	assert(pq);
//	assert(pq->head && pq->tail);
//	QNode* next = pq->head->next;
//	free(pq->head);//在这里，如果删除最后一个元素的时候，tail指向的空间释放，tail就会成为野指针
//	pq->head = next;
//}
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head && pq->tail);
	QNode* next = pq->head->next;
	if (next == NULL)
	{
		free(pq->head);
		pq->head =pq->tail = next;
	}
	else
	{
		free(pq->head);
		pq->head = next;
	}
}


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

size_t QueueSize(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	size_t size = 0;
	while (cur)
	{
		size++;
		cur = cur->next;
	}
    return size;
}
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->tail);
	return pq->tail->data;
}

注意：（1）size_t 就是unsigned int

（2）当出现a->b->c的时候，就要注意最后面的时候，是否会出现野指针。

三、习题

3.1 选择题

1.循环队列的存储空间为 Q(1:100) ，初始状态为 front=rear=100 。经过一系列正常的入队与退队操作后， front=rear=99 ，则循环队列中的元素个数为（ D）

A 1

B 2

C 99

D 0

2.以下( B)不是队列的基本运算？

A 从队尾插入一个新元素

B 从队列中删除第i个元素

C 判断一个队列是否为空

D 读取队头元素的值

3.现有一循环队列，其队头指针为front，队尾指针为rear；循环队列长度为N,实际最多可存储N-1个数据。其队内有效长度为？(假设队头不存放数据)(B)

A (rear - front + N) % N + 1

B (rear - front + N) % N 因为rear指向的内容是空

C (rear - front) % (N + 1)

D (rear - front + N) % (N - 1)

3.2 用队列实现栈

https://leetcode.cn/problems/implement-stack-using-queues/

代码如下：

//定义一个栈的结构体，栈里面是两个队列
typedef struct {
    Queue q1;//q1和q2分别是结构体
    Queue q2;
} MyStack;

//相当于初始化，由于需要返回的是结构体指针，所以不能在函数里创建一个结构体，返回结构体的地址，因为出了这个函数，又被销毁了。所以应该malloc一个结构体。
MyStack* myStackCreate() {
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));//结构体的地址
    assert(pst);
    QueueInit(&pst->q1);//->的优先级>&的优先级
    QueueInit(&pst->q2);//两个队列初始化完成，就表示栈也初始化完成
    return pst;
}

void myStackPush(MyStack* obj, int x) {
    assert(obj);
    //在不为空的队列里面插入数，
    if (!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
}
//删除栈顶的数据，并返回栈顶的数据
int myStackPop(MyStack* obj) {
    assert(obj);
    Queue* emptyQ = &obj->q1;
    Queue* nonEmptyQ = &obj->q2;
    if (!QueueEmpty(&obj->q1))
    {
        emptyQ = &obj->q2;
        nonEmptyQ = &obj->q1;
    }
    while (QueueSize(nonEmptyQ) > 1)
    {
        int front = QueueFront(nonEmptyQ);
        QueuePush(emptyQ, front);
        QueuePop(nonEmptyQ);
    }
    int top = QueueFront(nonEmptyQ);
    QueuePop(nonEmptyQ);
    return top;
}
//栈顶的数据，就是队列的队尾的数据
int myStackTop(MyStack* obj) {
    assert(obj);
    if (!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}
//两个队列都为空，才能证明栈为空
bool myStackEmpty(MyStack* obj) {
    assert(obj);
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

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

思路：入栈：push数据到不为空的队列；出栈：把不为空的队列数据前N-1导入另一个空队列，把最后一个剩下的删掉。【本质是保持一个队列存储数据，另外一个队列空着，要出栈时，空队列用来导数据】

3.3 用栈实现队列

链接：力扣

代码如下：

typedef struct {
    ST pushST;//定义结构体
    ST popST;
} MyQueue;

//初始化
MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    assert(obj);
    StackInit(&obj->pushST);
    StackInit(&obj->popST);
    return obj;
}

void myQueuePush(MyQueue* obj, int x)
{
    assert(obj);
    StackPush(&obj->pushST,x);
}
//
int myQueuePop(MyQueue* obj) 
{
    assert(obj);
    if (StackEmpty(&obj->popST))
    {
        while (!StackEmpty(&obj->pushST))
       {
            StackPush(&obj->popST, StackTop(&obj->pushST));
            StackPop(&obj->pushST);//把数据倒过去之后，需要删掉pushST里的数据
       }
    }
    int front = StackTop(&obj->popST);
    StackPop(&obj->popST);
    return front;
}

//返回队列开头的元素，如果popST没有元素就导入元素，有数据就直接导入
int myQueuePeek(MyQueue* obj) 
{
    assert(obj);
    if (StackEmpty(&obj->popST))
    {
        while (!StackEmpty(&obj->pushST))
       {
            StackPush(&obj->popST, StackTop(&obj->pushST));
            StackPop(&obj->pushST);//把数据倒过去之后，需要删掉pushST里的数据
       }
    }
    return StackTop(&obj->popST);
}

bool myQueueEmpty(MyQueue* obj) 
{
    assert(obj);
    return StackEmpty(&obj->pushST) && StackEmpty(&obj->popST);
}
//两层free,是因为free是把指向的空间free掉，仅仅free掉地址内容存放的空间，并没有free掉地址所指向的内容，但是obj里面的指针又指向了别的空间。
void myQueueFree(MyQueue* obj) 
{
    assert(obj);
    StackDestory(&obj->pushST);
    StackDestory(&obj->popST);
    free(obj);
    obj = NULL;
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

思路：进队列：push数据到不为空的栈；出队列：把不为空的栈数据导入另一个空的栈，然后，另一个栈依次出栈即可【因为，导入另一个栈的时候，顺序刚好是我们想要的队列顺序】【本质是保持一个队列存储数据，另外一个队列空着，要出栈时，空队列用来导数据】

注意：（1）用来删除的那个栈，删除完毕之后，才能导入新的数据。否则会导致出栈的数据顺序，不是我们想要的。

（2）两层free,是因为free是把指向的空间free掉，仅仅free存放该地址内容的空间，并没有free掉地址所指向的空间，但是obj里面的指针又指向了别的空间。

3.4 设计循环队列

链接：力扣

代码如下：（数组）

typedef struct {
    int* a;
    int head;
    int tail;
    int k;
} MyCircularQueue;

bool myCircularQueueIsFull(MyCircularQueue* obj);
bool myCircularQueueIsEmpty(MyCircularQueue* obj);

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    assert(obj);
    obj->a = (int*)malloc((k+1)*sizeof(int));
    assert(obj->a);
    obj->head = obj->tail = 0;
    obj->k = k;
    return obj;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    assert(obj);
    assert(obj->a);
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    else
    {
        if ((obj->head) == (obj->tail))
        {
            obj->a[obj->head]=  obj->a[obj->tail] = value;
        }
        else
        {
            obj->a[obj->tail] = value;
        }

        if (obj->tail == obj->k)
        {
            obj->tail = 0;
        }
        else
        {
            obj->tail++;
        }
        return true;
    }
    
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    assert(obj);
    assert(obj->a);
    if (myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        if (obj->head == obj->k)
        {
            obj->head = 0;
        }
        else
        {
            obj->head++;
        }
        return true;
    }
}

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

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

bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    assert(obj);
    assert(obj->a);
    return obj->head == obj->tail;

}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    assert(obj);
    assert(obj->a);
    if ((obj->head == 0) && (obj->tail == obj->k))
    {
        return true;
    }
    else
    {
        return (obj->tail) + 1 == obj->head;
    }
}

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

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/

思路：用数组时，两个下标，一个head，一个tail【用链表时，分别代表地址】。刚开始同时指向第一个位置，当插入数据时，tail++【tail永远指向下一个位置】；当删除数据时，head--.

注意：（1）当head==tail的时候，说明队列为空。但是循环队列没有一个位置的时候，满的情况下，head也是等于tail的。所以，为了避免空和满混淆，无法区分，我们一般多开一个空间，head==tail时是空，tail下一个位置是head时，就是满。【链表的话，队尾的值不太好取出来，所以用数组】

理论知识：