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

循环队列(Circular Queue)

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

标签：

循环队列(Circular Queue)

1. 循环队列的概念

1.1 循环队列的定义

  • 为了能够充分地使用数组中的存储空间，克服”假溢出”现象，可以把数组的前端和后端连接起来，形成一个环形的表，即把存储队列元素的表从逻辑上看成一个环，成为循环队列(circular queue)。

1.2 循环队列中各元素的逻辑及存储关系

  • 循环队列的首尾相接，当队头指针front和队尾指针rear进到maxSize-1后，再前进一个位置就自动到0。这可以利用除法取余的运算(%)来实现。
    (1)队头指针进1：front = (front + 1) % maxSize；
    (2)队尾指针进1：rear = (rear + 1) % maxSize；

1.3 循环队列的初始化、插入和删除

  • 循环队列的队头指针和队尾指针初始化时都置为0：front = rear = 0。
  • 在队尾插入新元素和删除队头元素时，两个指针都按顺时针方向进1。当他们进到maxSize-1时，并不表示表的终结，只要有需要，利用%运算可以前进到数组的0号位置。
  • 队空条件：如果循环队列读取元素的速度快于存入元素的速度，队头指针很快追上了队尾指针，一旦到了front == rear时，则队列就变成空队列。
  • 队满条件：如果队列存入元素的速度快于读取元素的速度，队尾指针很快就赶上了队头指针，一旦队列满就不能再加入新元素了。为了区别于队空条件，用(rear +１) ％ maxSize == front来判断是否队已满，就是说，让rear指到front的前一位置就认为队已满。
  • 注：如果不留一个空位置，让队尾指针rear一直走到这个位置，必然有rear == front，则队空条件和队满条件就混淆了。除非另加队空或队满标识，否则无从分辨到底是队空，还是队满。因此，在循环队列中，最多只能存放maxSize-1个元素。
  • 循环队列的初始化、插入和删除模型：
    技术分享

2. 循环队列的实现

2.1 队列基类的定义

  • 文件：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.2 循环队列的类定义及其操作的实现

  • 文件：CircularQueue.h

    
#ifndef CIRCULAR_QUEUE_H_


#define CIRCULAR_QUEUE_H_



#include "Queue.h"


#include <iostream>


#include <string>


#include <strstream>


using namespace std;

const int defaultSize = 50;

template <class T>
class CircularQueue : public Queue<T>
{
public:
    CircularQueue(int sz = defaultSize);        //构造函数
    virtual ~CircularQueue();                   //析构函数
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 CircularQueue<T>& s); //输出队列元素的重载操作<<
private:
    T *elements;    //存放队列元素的队列数组
    int front;      //队头指针
    int rear;       //队尾指针
    int maxSize;    //队列最大可容纳元素个数
};

//构造函数
template <class T>
CircularQueue<T>::CircularQueue(int sz)
{
    cout << "$ 执行构造函数" << endl;
    if (sz >= 0)
    {
        maxSize = sz;
        front = rear = 0;
        elements = new T[maxSize];
    }
}

//析构函数
template <class T>
CircularQueue<T>::~CircularQueue()
{
    cout << "$ 执行析构函数" << endl;
    delete[] elements;
    elements = NULL;
}

//新元素x入队
template <class T>
bool CircularQueue<T>::EnQueue(const T& x)
{
    if (true == IsFull())
    {
        return false;
    }
    elements[rear] = x;
    rear = (rear + 1) % maxSize;
    return true;
}

//队头元素出队，并将该元素的值保存至x
template <class T>
bool CircularQueue<T>::DeQueue(T& x)
{
    if (true == IsEmpty())
    {
        return false;
    }
    x = elements[front];
    front = (front + 1) % maxSize;
    return true;
}

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

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

//判断队列是否为满
template <class T>
bool CircularQueue<T>::IsFull() const
{
    return ((rear + 1) % maxSize == front) ? true : false;
}

//计算队列中元素个数
template <class T>
int CircularQueue<T>::getSize() const
{
    return (rear - front + maxSize) % maxSize;
}

//清空队列的内容
template <class T>
void CircularQueue<T>::MakeEmpty()
{
    delete[] elements;
    front = rear = 0;
    elements = new T[maxSize];
}

//输出队列元素的重载操作<<
template <class T>
ostream& operator<<(ostream& os, const CircularQueue<T>& q)
{
    for (int i = q.front; i != q.rear; i = (i+1)%q.maxSize)
    {
        os << "[" << i << "]" << " : " << q.elements[i] << endl;
    }
    return os;
}


#endif /* CIRCULAR_QUEUE_H_ */

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

  • 文件：main.cpp

    
#include "CircularQueue.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>
CircularQueue<T>* construct_cirqueue()
{
    cout << "\n==> 创建循环队列" << endl;
    int n_maxsize = get_maxsize<T>();
    CircularQueue<T> *cirQueue = new CircularQueue<T>(n_maxsize);
    return cirQueue;
}

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

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

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

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

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

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

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

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

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

//循环队列操作选择
template <class T>
void select_operation(CircularQueue<T>* cirQueue)
{
    if (NULL == cirQueue)
    {
        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(cirQueue);
                break;
            }
            case DEQUEUE://队头元素出队，并将该元素的值保存至x
            {
                dequeue(cirQueue);
                break;
            }
            case GETFRONT://读取队头元素，并将该元素的值保存至x
            {
                getfront(cirQueue);
                break;
            }
            case ISEMPTY://判断队列是否为空
            {
                isempty(cirQueue);
                break;
            }
            case ISFULL://判断队列是否为满
            {
                isfull(cirQueue);
                break;
            }
            case GETSIZE://计算队列元素个数
            {
                getsize(cirQueue);
                break;
            }
            case MAKEEMPTY://清空队列的内容
            {
                makeempty(cirQueue);
                break;
            }
            case OPERATOR_OSTREAM://输出队列元素的重载操作<<
            {
                operator_ostream(cirQueue);
                break;
            }
            default:
            {
                cout << "* 请输入正确的功能选项编号" << endl;
                break;
            }
        }
    }
}

int main(int argc, char* argv[])
{
    print_description();
    CircularQueue<int> *cirQueue = construct_cirqueue<int>();
    select_operation(cirQueue);
    destory_cirqueue(cirQueue);
    system("pause");
    return 0;
}

参考文献：
[1]《数据结构(用面向对象方法与C++语言描述)(第2版)》殷人昆——第三章
[2]《C/C++常用算法手册》秦姣华、向旭宇——第二章
[3]?百度搜索关键字：循环队列

循环队列(Circular Queue)

标签：

原文地址：http://blog.csdn.net/cainv89/article/details/51509972
踩
(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
迷上了代码！