码迷，mamicode.com
首页 > 其他好文 > 详细

链式队列(Linked Queue)

时间：2016-05-30 15:24:56      阅读：189      评论：0      收藏：0      [点我收藏+]

标签：

链式队列(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]?百度搜索关键字：链式队列

链式队列(Linked Queue)

标签：

原文地址：http://blog.csdn.net/cainv89/article/details/51526229
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！