链式队列(Linked Queue)

链式队列(Linked Queue)

1. 链式队列的概念

1.1 链式队列的定义

  • 链式队列是基于链表的存储表示实现的队列。

1.2 链式队列中各元素的逻辑及存储关系

  • 链式队列可以采用单链表作为其存储表示，因此，可以在链式队列的声明中用单链表定义它的存储空间。
  • 链式队列的队头指针指向单链表的第一个结点，队尾指针指向单链表的最后一个结点。
  • 注：链式队列的队头元素存放在单链表的第一个结点内，若要从队列中退出一个元素，必须从单链表中删去第一个结点，而存放着新元素的结点应插在队列的队尾，即单链表的最后一个结点后面，这个新节点将成为新的队尾。

1.3 链式队列的特点

  • 用单链表表示的链式队列特别适合于数据元素变动比较大的情况，而且不存在队列满而产生溢出的情况。
  • 若程序中要使用多个队列，与多个栈的情形一样，用链接表示不仅能够提高效率，还可以达到共享存储空间的目的。
  • 使用链式队列不会出现存储分配不合理的问题，也不需要进行存储的移动，

2. 链式队列的实现

2.1 链表结点结构的定义

  • 文件：LinkNode.h

    
#ifndef LINK_NODE_H_

#define LINK_NODE_H_

#include <iostream>

#include <string>

#include <strstream>

using namespace std;

template <class T>
struct LinkNode         //链表结点类的定义
{
    T data;             //数据域
    LinkNode<T> *link;  //指针域——后继指针
    //仅初始化指针成员的构造函数
    LinkNode(LinkNode<T>* ptr = NULL){ link = ptr; }
    //初始化数据与指针成员的构造函数
    LinkNode(const T& value, LinkNode<T>* ptr = NULL){ data = value; link = ptr; }
};

#endif /* LINK_NODE_H_ */

2.2 队列基类的定义

  • 文件：Queue.h

    
#ifndef QUEUE_H_

#define QUEUE_H_

template <class T>
class Queue
{
public:
    Queue(){}                               //构造函数
    virtual ~Queue(){}                      //析构函数
public:
    virtual bool EnQueue(const T& x) = 0;       //新元素x入队
    virtual bool DeQueue(T& x) = 0;             //队头元素出队，并将该元素的值保存至x
    virtual bool getFront(T& x) const = 0;      //读取队头元素，并将该元素的值保存至x
    virtual bool IsEmpty() const = 0;           //判断队列是否为空
    virtual bool IsFull() const = 0;            //判断队列是否为满
    virtual int getSize() const = 0;            //计算队列中元素个数
    virtual void MakeEmpty() = 0;               //清空队列的内容
};

#endif /* QUEUE_H_ */

2.3 链式队列的类定义及其操作的实现

  • 文件：LinkedQueue.h

    
#ifndef LINKED_QUEUE_H_

#define LINKED_QUEUE_H_

#include "LinkNode.h"

#include "Queue.h"

template <class T>
class LinkedQueue : public Queue<T>
{
public:
    LinkedQueue();                      //构造函数
    virtual ~LinkedQueue();             //析构函数
public:
    virtual bool EnQueue(const T& x);       //新元素x入队
    virtual bool DeQueue(T& x);             //队头元素出队，并将该元素的值保存至x
    virtual bool getFront(T& x) const;      //读取队头元素，并将该元素的值保存至x
    virtual bool IsEmpty() const;           //判断队列是否为空
    virtual bool IsFull() const;            //判断队列是否为满
    virtual int getSize() const;            //计算队列中元素个数
    virtual void MakeEmpty();               //清空队列的内容
public:
    template <class T>
    friend ostream& operator<<(ostream& os, const LinkedQueue<T>& s);   //输出队列中元素的重载操作<<
private:
    LinkNode<T> *front; //队头指针，即链头指针
    LinkNode<T> *rear;  //队尾指针，即链尾指针
};

//构造函数
template <class T>
LinkedQueue<T>::LinkedQueue()
: front(NULL), rear(NULL)
{
    cout << "$ 执行构造函数" << endl;
}                       

//析构函数
template <class T>
LinkedQueue<T>::~LinkedQueue()
{
    cout << "$ 执行析构函数" << endl;
    MakeEmpty();
}   

//新元素x入队
template <class T>
bool LinkedQueue<T>::EnQueue(const T& x)
{
    LinkNode<T> *newNode = new LinkNode<T>(x);
    if (NULL == newNode)
    {
        return false;
    }

    if (NULL == front)
    {
        front = newNode;
        rear = newNode;
    }
    else
    {
        rear->link = newNode;
        rear = rear->link;
    }
    return true;
}

//队头元素出队，并将该元素的值保存至x
template <class T>
bool LinkedQueue<T>::DeQueue(T& x)
{
    if (true == IsEmpty())
    {
        return false;
    }
    LinkNode<T> *curNode = front;
    front = front->link;
    x = curNode->data;
    delete curNode;
    return true;
}

//读取队头元素，并将该元素的值保存至x
template <class T>
bool LinkedQueue<T>::getFront(T& x) const
{
    if (true == IsEmpty())
    {
        return false;
    }
    x = front->data;
    return true;
}

//判断队列是否为空
template <class T>
bool LinkedQueue<T>::IsEmpty() const
{
    return (NULL == front) ? true : false;
}

//判断队列是否为满
template <class T>
bool LinkedQueue<T>::IsFull() const
{
    return false;
}

//计算队列中元素个数
template <class T>
int LinkedQueue<T>::getSize() const
{
    int count = 0;
    LinkNode<T> *curNode = front;
    while (NULL != curNode)
    {
        curNode = curNode->link;
        count++;
    }
    return count;
}

//清空队列的内容
template <class T>
void LinkedQueue<T>::MakeEmpty()
{
    LinkNode<T> *curNode = NULL;
    while (NULL != front)           //当链表不为空时，删去链表中所有结点
    {
        curNode = front;            //保存被删结点
        front = curNode->link;      //被删结点的下一个结点成为头结点
        delete curNode;             //从链表上摘下被删结点
    }
}

//输出队列中元素的重载操作<<
template <class T>
ostream& operator<<(ostream& os, const LinkedQueue<T>& s)
{
    int i = 0;
    LinkNode<T> *curNode = s.front;
    while (NULL != curNode)
    {
        os << "[" << i++ << "]" << " : " << curNode->data << endl;
        curNode = curNode->link;
    }
    return os;
}

#endif /* LINKED_QUEUE_H_ */

2.4 主函数(main函数)的实现

  • 文件：main.cpp

    
#include "LinkedQueue.h"

#define EXIT 0              //退出

#define ENQUEUE 1           //新元素x入队

#define DEQUEUE  2          //队头元素出队，并将该元素的值保存至x

#define GETFRONT 3          //读取队头元素，并将该元素的值保存至x

#define ISEMPTY  4          //判断队列是否为空

#define ISFULL 5            //判断队列是否为满

#define GETSIZE 6           //计算队列中元素个数

#define MAKEEMPTY 7         //清空队列的内容

#define OPERATOR_OSTREAM 8  //输出队列元素的重载操作<<

void print_description()
{
    cout << "------------------------------>链式队列<------------------------------" << endl;
    cout << "功能选项说明：" << endl;
    cout << "#0： 退出" << endl;
    cout << "#1： 新元素x入队" << endl;
    cout << "#2： 队头元素出队，并将该元素的值保存至x" << endl;
    cout << "#3： 读取队头元素，并将该元素的值保存至x" << endl;
    cout << "#4： 判断队列是否为空" << endl;
    cout << "#5： 判断队列是否为满" << endl;
    cout << "#6： 计算队列中元素个数" << endl;
    cout << "#7： 清空队列的内容" << endl;
    cout << "#8： 输出队列元素的重载操作<<" << endl;
    cout << "--------------------------------------------------------------------" << endl;
}

//判断输入的字符串每个字符是否都是数值0~9
bool IsNumber(const string& s_num)
{
    for (size_t i = 0; i < s_num.size(); i++)
    {
        if ((s_num[i] < ‘0‘) || (s_num[i] > ‘9‘))
        {
            return false;
        }
    }
    return true;
}

//类型转换——将string型转为模板类型T
template <class T>
T StrToTtype(const string& s_num)
{
    T n_num;
    strstream ss_num;
    ss_num << s_num;
    ss_num >> n_num;
    return n_num;
}

//输入数据值
template <class T>
T get_data()
{
    cout << "> 请输入数据值，data = ";
    string s_data;
    cin >> s_data;
    return StrToTtype<T>(s_data);
}

//输入数组的最大长度
template <class T>
int get_maxsize()
{
    cout << "> 请输入数组的最大长度，maxsize = ";
    string s_maxsize;
    cin >> s_maxsize;
    while (false == IsNumber(s_maxsize))
    {
        cout << "* 输入有误，请重新输入：";
        cin >> s_maxsize;
    }
    return atoi(s_maxsize.c_str());
}

//构造链式队列
template <class T>
LinkedQueue<T>* construct_linkedqueue()
{
    cout << "\n==> 创建链式队列" << endl;
    LinkedQueue<T> *linkedQueue = new LinkedQueue<T>;
    return linkedQueue;
}

//析构链式队列
template <class T>
void destory_linkedqueue(LinkedQueue<T>* linkedQueue)
{
    cout << "\n==> 释放链式队列在堆中申请的空间，并将指向该空间的指针变量置为空" << endl;
    delete linkedQueue;
    linkedQueue = NULL;
}

//新元素x入队
template <class T>
void enqueue(LinkedQueue<T>* linkedQueue)
{
    cout << "$ 执行新元素x入队函数" << endl;
    T data = get_data<T>();
    if (false == linkedQueue->EnQueue(data))
    {
        cout << "* 入队失败" << endl;
        return;
    }
    cout << "* 入队成功，data = " << data << endl;
}

//队头元素出队，并将该元素的值保存至x
template <class T>
void dequeue(LinkedQueue<T>* linkedQueue)
{
    cout << "$ 执行队头元素出队并将该元素的值保存至x函数" << endl;
    T data;
    if (false == linkedQueue->DeQueue(data))
    {
        cout << "* 出队失败" << endl;
        return;
    }
    cout << "* 出队成功，data = " << data << endl;
}

//读取队头元素，并将该元素的值保存至x
template <class T>
void getfront(LinkedQueue<T>* linkedQueue)
{
    cout << "$ 执行读取队头元素并将该元素的值保存至x函数" << endl;
    T data;
    if (false == linkedQueue->getFront(data))
    {
        cout << "* 读取队头元素失败" << endl;
        return;
    }
    cout << "* 读取队头元素成功，data = " << data << endl;
}

//判断队列是否为空
template <class T>
void isempty(LinkedQueue<T>* linkedQueue)
{
    cout << "$ 执行判断队列是否为空函数，IsEmpty = " << linkedQueue->IsEmpty() << endl;
}

//判断队列是否为满
template <class T>
void isfull(LinkedQueue<T>* linkedQueue)
{
    cout << "$ 执行判断队列是否为满函数，IsFull = " << linkedQueue->IsFull() << endl;
}

//计算队列中元素个数
template <class T>
void getsize(LinkedQueue<T>* linkedQueue)
{
    cout << "$ 执行计算队列中元素个数函数，Size = " << linkedQueue->getSize() << endl;
}

//清空队列的内容
template <class T>
void makeempty(LinkedQueue<T>* linkedQueue)
{
    cout << "$ 执行清空队列的内容函数" << endl;
    linkedQueue->MakeEmpty();
}

//输出队列元素的重载操作<<
template <class T>
void operator_ostream(LinkedQueue<T>* linkedQueue)
{
    cout << "$ 执行输出队列元素的重载操作<<函数" << endl;
    cout << *linkedQueue;//或operator<<(cout, *linkedQueue);
}

//链式队列操作选择
template <class T>
void select_operation(LinkedQueue<T>* linkedQueue)
{
    if (NULL == linkedQueue)
    {
        cout << "* 没有构造链式队列，请先构造链式队列。" << endl;
        return;
    }

    string s_operation;
    while (s_operation != "0")
    {
        cout << "\n==> 请输入功能选项编号(按\"0\"退出程序)：";
        cin >> s_operation;
        while (false == IsNumber(s_operation))
        {
            cout << "* 输入有误，请重新输入：";
            cin >> s_operation;
        }
        int n_operation = atoi(s_operation.c_str());
        switch (n_operation)
        {
        case EXIT://退出
        {
            cout << "$ 退出程序" << endl;
            break;
        }
        case ENQUEUE://新元素x入队
        {
            enqueue(linkedQueue);
            break;
        }
        case DEQUEUE://队头元素出队，并将该元素的值保存至x
        {
            dequeue(linkedQueue);
            break;
        }
        case GETFRONT://读取队头元素，并将该元素的值保存至x
        {
            getfront(linkedQueue);
            break;
        }
        case ISEMPTY://判断队列是否为空
        {
            isempty(linkedQueue);
            break;
        }
        case ISFULL://判断队列是否为满
        {
            isfull(linkedQueue);
            break;
        }
        case GETSIZE://计算队列元素个数
        {
            getsize(linkedQueue);
            break;
        }
        case MAKEEMPTY://清空队列的内容
        {
            makeempty(linkedQueue);
            break;
        }
        case OPERATOR_OSTREAM://输出队列元素的重载操作<<
        {
            operator_ostream(linkedQueue);
            break;
        }
        default:
        {
            cout << "* 请输入正确的功能选项编号" << endl;
            break;
        }
        }
    }
}

int main(int argc, char* argv[])
{
    print_description();
    LinkedQueue<int> *linkedQueue = construct_linkedqueue<int>();
    select_operation(linkedQueue);
    destory_linkedqueue(linkedQueue);
    system("pause");
    return 0;
}

参考文献：

[1]《数据结构(用面向对象方法与C++语言描述)(第2版)》殷人昆——第三章

[2]《C/C++常用算法手册》秦姣华、向旭宇——第二章

[3]?百度搜索关键字：链式队列

时间： 2024-11-05 12:13:12

链式队列(Linked Queue)的相关文章

数据结构Java实现07----队列：顺序队列&amp;顺序循环队列、链式队列、顺序优先队列

数据结构Java实现07----队列:顺序队列&顺序循环队列.链式队列.顺序优先队列 一.队列的概念: 队列(简称作队,Queue)也是一种特殊的线性表,队列的数据元素以及数据元素间的逻辑关系和线性表完全相同,其差别是线性表允许在任意位置插入和删除,而队列只允许在其一端进行插入操作在其另一端进行删除操作. 队列中允许进行插入操作的一端称为队尾,允许进行删除操作的一端称为队头.队列的插入操作通常称作入队列,队列的删除操作通常称作出队列. 下图是一个依次向队列中插入数据元素a0,a1,...,an-

有序链式队列

  编写头文件 struct queue { int num;            //代表数据 int high;           //优先级1111 struct queue *pNext;//存储下一个节点的地址 }; typedef  struct queue Queue;                           //简化队列 Queue * init(Queue *queueHead);                        //初始化 Queue *

数据结构基础(14) --链式队列的设计与实现

链式队列是基于单链表的一种存储表示, 其形状如下图所示: (队列的队头指针指向单链表的第一个结点, 队尾指针指向单链表的最后一个结点, 注意没有无用的空[头/尾]节点) 用单链表表示的链式队列特别适合于数据元素变动比较大的情况, 而且不存在队列满而产生溢出的情况; 链式队列结点构造: [这次我们将节点构造成了类LinkQueue的嵌套类] struct ChainNode { ChainNode(const Type &_data, ChainNode *_next = NULL) :data(

不带头结点的链式队列进出队操作

/* 不带头结点的链式队列进出队操作 */ #include <stdio.h> #include <stdlib.h> #define ElementType int typedef struct QNode *Queue; typedef struct Node{ ElementType Data; struct Node *Next; }; typedef struct QNode{ struct Node *front; struct Node *rear; }; void

顺序队列和链式队列的实现

队列是一种常用的数据结构,它跟栈一样,操作都受到限制,队列只允许从一端进数据,另一端出数据.队列跟栈不同,栈是一种"后进先出"的模式,而队列是一种"先进先出"的操作模式.就好比日常排队一样,先排队的先出,后排队的后出.例如,进入队列的顺序是1,2,3,4,5则出队列的顺序是1,2,3,4,5(只考虑一次性出列的情况). 队列也分顺序队列和链式队列,跟顺序栈和链表栈一样,顺序队列同样是基于数组实现,链式队列则是基于链表实现. 顺序队列: //顺序队列 #include

链式队列总结

基本数据结构之-链式队列 链式队列就是一个操作受到限制的单链表,学会了单链表再来写这个就是轻松加愉快,但是貌似我去用了两个小时搞定,主要是基础差! 队列的基本操作就是入栈和出栈,还可以看到对头和对尾 如果维护了长度参数,那么也可以返回一个长度 不说理论了,直接上代码吧! 首先定义基本数据结构的结构体: typedef struct _LINKQUEUENODE { struct _LINKQUEUENODE *next; }LinkQueueNode; typedef struct _LINKQ

队列的实现：链式队列

队列常常也使用链式存储的方式来实现.为了方便操作,同顺序存储一样,我们要维护一个头指针和一个尾指针.如下图: 在链式队列中显然不会出现假溢出的情况.但在出队时,要及时释放内存.由于在队列的实现:顺序队列中,对队列的描述已经很清楚了.就闲话不多说,直接上代码: 类定义和类实现 #include<iostream> #include<iomanip> using namespace std; typedef int ELemType; class QNode //节点类型 { publ

队列（链式队列）

链式队列----用链表实现,链式队列就是一个操作受限的单向链表,如果读者了解单向链表的建立过程,那理解链式队列就很容易了,先回顾一下单向链表的建立过程 (不熟悉单向链表的可以先看看另一片随笔,再回来看链式队列理解起来更容易?https://www.cnblogs.com/lanhaicode/p/10304567.html) 单向链表 单向链表节点的组成部分 1 struct link 2 { 3 int data; 4 struct link *next; 5 }; 数据域:data----用

数据结构之---C语言实现链式队列

//链式队列的存储 //杨鑫 #include <stdio.h> #include <stdlib.h> typedef int QElemType; //定义节点 typedef struct QNode { QElemType data; struct QNode *next; }QNode, *QueuePtr; //定义指针 typedef struct { QueuePtr front; QueuePtr rear; }LinkQueue; //插入元素e进入队列 vo