数据结构基础队列

最新推荐文章于 2025-05-27 20:07:06 发布

野尽

最新推荐文章于 2025-05-27 20:07:06 发布

阅读量225

点赞数

分类专栏：数据结构基础文章标签：队列指针数据结构链表

本文链接：https://blog.youkuaiyun.com/PFzcnds8310__/article/details/105230813

版权

数据结构基础专栏收录该内容

7 篇文章

订阅专栏

本文介绍了队列这一数据结构，详细阐述了队列的顺序存储结构及其解决假溢出的循环队列实现，以及链式存储结构的链队列，包括其头结点和队头队尾指针的使用。最后对比分析了循环队列和链队列的特点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

数据结构基础队列

队列

队列

队列（queue）是只允许在一端进行插入操作，在另一端进行删除的删除操作的线性表。允许插入的一端称为队尾，允许删除的一端称为队头。

队列的顺序存储结构及实现

队列是特殊的线性表，考虑到队列的顺序存储问题，设置队头和队尾的两个指针，并且约定：队头指针front指向队头元素的前一个位置，队尾指针rear指向队尾元素。但是随着队列的插入和删除操作的进行，有一种情况，当元素被插入到数组中下标最大的位置后，队列的空间就用尽了，但此时数组的下标小的位置还有空闲空间，这种现象叫做“假溢出”。
解决假溢出的方法：将存储队列的数组看成是头尾相接的循环结构。队列的这种头尾相接的顺序存储结构称为 循环队列。
队空条件：front=rear。
队满条件：（rear+1）%QueueSize（队列长度）=front。

循环队列实现：
SeqQueue.h

//
// Created by 野尽 on 2020/3/31.
//

#ifndef SEQLIST_CLASSTEMPLATEINHFILE__SEQQUEUE_H
#define SEQLIST_CLASSTEMPLATEINHFILE__SEQQUEUE_H

#include <iostream>
using namespace std;

const int QueueSize = 100;

template <class DataType>
class SeqQueue
{
public:

    // 构造函数，初始化空队列
    SeqQueue();

    // 析构函数
    ~SeqQueue();

    // 入队操作，将元素 x 入队
    void EnQueue(DataType x);

    // 出队操作，将队头元素出队
    DataType DeQueue();

    // 取出队头元素
    DataType GetQueue();

    // 判断队列是否为空
    int Empty();

private:

    DataType data[QueueSize];
    int front, rear;
};

template<class DataType>
SeqQueue<DataType>::SeqQueue() {

    front = rear = QueueSize - 1;
}

template<class DataType>
SeqQueue<DataType>::~SeqQueue() {

    cout<<"SeqQueue had been cleaned!"<<endl;
}

template<class DataType>
void SeqQueue<DataType>::EnQueue(DataType x) {

    if ((rear + 1) % QueueSize == front)
        throw "Overflow!";

    rear = (rear + 1) % QueueSize;
    data[rear] = x;
}

template<class DataType>
DataType SeqQueue<DataType>::DeQueue() {

    if (rear == front)
        throw "Underflow!";

    // 队列头指针指向的是第一个元素的前一个位置
    front = (front + 1) % QueueSize;
    DataType x = data[front];

    return x;
}

template<class DataType>
DataType SeqQueue<DataType>::GetQueue() {

    if (rear == front)
        throw "Underflow!";
    if ((rear + 1) % QueueSize == front)
        throw "Overflow!";

    return data[(front + 1) % QueueSize];
}

template<class DataType>
int SeqQueue<DataType>::Empty() {

    if (rear == front)
        return 1;
    else
        return 0;
}

#endif //SEQLIST_CLASSTEMPLATEINHFILE__SEQQUEUE_H

main.cpp

#include "SeqQueue.h"

int main() {
    // SeqQueue.h
    SeqQueue <int> seqQueue;
    int i = seqQueue.Empty();
    if (i == 1)
        cout<<"SeqQueue 为空!"<<endl;
    if (i == 0)
        cout<<"SeqQueue 不空！"<<endl;
    cout<<endl;

    int x = 245;
    seqQueue.EnQueue(x);
    cout<<"执行入队后："<<endl;
    i = seqQueue.Empty();
    if (i == 1)
        cout<<"SeqQueue 为空!"<<endl;
    if (i == 0)
        cout<<"SeqQueue 不空！"<<endl;
    cout<<endl;

    x = seqQueue.GetQueue();
    cout<<"队列的头元素为："<< x <<endl;
    cout<<endl;

    seqQueue.DeQueue();
    cout<<"执行出队后："<<endl;
    i = seqQueue.Empty();
    if (i == 1)
        cout<<"SeqQueue 为空!"<<endl;
    if (i == 0)
        cout<<"SeqQueue 不空！"<<endl;
    cout<<endl;

    return 0;
}

测试结果：

SeqQueue 为空!

执行入队后：
SeqQueue 不空！

队列的头元素为：245

执行出队后：
SeqQueue 为空!

SeqQueue had been cleaned!

队列的链接存储结构及实现

队列的链接存储结构称为 链队列。

链队列在单链表的基础上改进。链队列加上了头结点，设置队头指针指向链队列的头结点，队尾指针指向终端结点。

链队列的实现：
LinkQueue.h

//
// Created by 野尽 on 2020/3/31.
//

#ifndef SEQLIST_CLASSTEMPLATEINHFILE__LINKQUEUE_H
#define SEQLIST_CLASSTEMPLATEINHFILE__LINKQUEUE_H

#include <iostream>
using namespace std;

template <class DataType>
struct Node
{
    DataType data;
    Node<DataType> * next;
};

template <class DataType>
class LinkQueue
{
public:

    // 构造函数，初始化一个空的链队列
    LinkQueue();

    // 构造函数，初始化一个链队列，链队列是尾插法
    LinkQueue(DataType a[], int n);

    // 析构函数
    ~LinkQueue();

    // 入队操作，将元素 x 入队
    void EnQueue(DataType x);

    // 出队操作，将队头元素出队
    DataType DeQueue();

    // 取链队列的队头元素
    DataType GetQueue();

    // 判断链队列是否为空
    int Empty();

    // 求线性表的长度
    int Length();

    // 按位查找，在线性表中查找第i个元素
    DataType Get(int i);

    // 按值查找，在线性表中查找值为 x 的元素序号
    int Locate(DataType x);

    // 遍历线性表
    void PrintList();

private:

    Node<DataType> *front, *rear;
};

template<class DataType>
LinkQueue<DataType>::LinkQueue() {

    Node<DataType> * s;
    s = new Node<DataType>;
    s->next = NULL;
    // 将队头指针和队尾指针都指向头结点
    front=rear=s;
}

template<class DataType>
LinkQueue<DataType>::~LinkQueue() {

    cout<<"LinkQueue had been cleaned!"<<endl;
}

template<class DataType>
void LinkQueue<DataType>::EnQueue(DataType x) {

    Node<DataType> * s;
    s = new Node<DataType>;
    s->data = x;
    s->next = NULL;
    rear->next = s;
    rear = s;
}

template<class DataType>
DataType LinkQueue<DataType>::DeQueue() {

    if (rear == front)
        throw "Underflow!";

    Node<DataType> * q;
    q = front->next;
    DataType x = q->data;

    front->next = q->next;
    if (q->next == NULL)
        rear = front;
    delete q;
    return x;
}

template<class DataType>
DataType LinkQueue<DataType>::GetQueue() {

    return front->next->data;
}

template<class DataType>
int LinkQueue<DataType>::Empty() {

    if (front==rear)
        return 1;
    else
        return 0;
}

template<class DataType>
LinkQueue<DataType>::LinkQueue(DataType *a, int n) {

    Node<DataType> * s;
    s = new Node<DataType>;
    s->next = NULL;
    front=rear=s;

    for (int i = 0; i < n; i++)
    {
        Node<DataType> * n;
        n = new Node<DataType>;
        n->next = NULL;

        n->data = a[i];
        rear->next = n;
        rear = n;
    }
}

template<class DataType>
int LinkQueue<DataType>::Length() {

    int count = 0;
    Node<DataType> * p = front->next;

    while (p != NULL)
    {
        p = p->next;
        count++;
    }

    return count;
}

template<class DataType>
DataType LinkQueue<DataType>::Get(int i) {

    int count = 1;
    Node<DataType> * p = front->next;

    while (p != NULL)
    {
        if (count == i)
            return p->data;
        else
        {
            p = p->next;
            count++;
        }
    }
}

template<class DataType>
int LinkQueue<DataType>::Locate(DataType x) {

    int count = 1;
    Node<DataType> * p = front->next;

    while (p != NULL)
    {
        if (p->data == x)
            return count;
        else
        {
            p = p->next;
            count++;
        }
    }
}

template<class DataType>
void LinkQueue<DataType>::PrintList() {

    Node<DataType> * p = front->next;

    while (p != NULL)
    {
        cout<<p->data<<" ";
        p = p->next;
    }

    cout<<endl;
}

#endif //SEQLIST_CLASSTEMPLATEINHFILE__LINKQUEUE_H

main.cpp

#include "LinkQueue.h"

int main() {
    // LinkQueue
    const int n = 10;
    int a[n] = {1,2,3,4,5,6,7,8,9,10};

    LinkQueue <int> linkQueue(a, n);
    linkQueue.PrintList();

    int i = linkQueue.Empty();
    if (i == 1)
        cout<<"LinkQueue 为空！"<<endl;
    else
        cout<<"LinkQueue 不空！"<<endl;

    int l = linkQueue.Length();
    cout<<"链队列的长度为："<<l<<endl;

    int x = linkQueue.Get(8);
    cout<<"第 "<<8<<" 个元素是："<<x<<endl;

    int j = linkQueue.Locate(9);
    cout<<9<<" 是第 "<<j<<" 个元素"<<endl;

    linkQueue.EnQueue(11);
    cout<<"执行入队后：";
    linkQueue.PrintList();

    linkQueue.DeQueue();
    cout<<"执行出队后：";
    linkQueue.PrintList();

    return 0;
}

测试结果：

1 2 3 4 5 6 7 8 9 10 
LinkQueue 不空！
链队列的长度为：10
第 8 个元素是：8
9 是第 9 个元素
执行入队后：1 2 3 4 5 6 7 8 9 10 11 
执行出队后：2 3 4 5 6 7 8 9 10 11 
LinkQueue had been cleaned!