数据结构C++版 王红梅 OJ习题

1016: 循环队列（2）

Description

 在循环队列中增加一个count变量，用来记录当前队列中数据个数，利用该值为0或QueueSize来判断队空或队满条件判断。循环队列类的定义、部分实现及主函数代码如下：

#include <iostream>
#include <string>
using namespace std;
const int QueueSize=5;
template <class T>        //定义模板类CirQueue
class CirQueue
{
public:
    CirQueue( );                 //构造函数，置空队
    ~CirQueue( );                //析构函数
    void EnQueue(T x);           //将元素x入队
    T DeQueue( );                //将队头元素出队
    T GetQueue( );               //取队头元素（并不删除）
    bool Empty( );               //判断队列是否为空，空返回true，否则返回false
 bool Full();                 //判断队列是否为满，满返回true，否则返回false
private:
    T data[QueueSize];           //存放队列元素的数组
    int front, rear;    //队头和队尾指针，分别指向队头元素所在数组的前一下标和队尾元素的数组下标
    int count;          //记录队列中数据个数
};

/*
 * 前置条件：队列不存在
 * 输    入：无
 * 功    能：初始化队列
 * 输    出：无
 * 后置条件：创建一个空队列
 */

template <class T>
CirQueue<T>::CirQueue( )
{
 front=rear=QueueSize-1;
 count=0;
}

/*
 * 前置条件：队列已存在
 * 输    入：无
 * 功    能：销毁队列
 * 输    出：无
 * 后置条件：释放队列所占用的存储空间
 */

template <class T>
CirQueue<T>::~CirQueue( )
{

}

/*
 * 前置条件：队列已存在
 * 输    入：无
 * 功    能：删除队头元素
 * 输    出：如果删除成功，返回被删元素值，否则，抛出删除异常
 * 后置条件：如果删除成功，队头减少了一个元素
 */

template <class T>
T CirQueue<T>::DeQueue( )
{
 if(Empty()) throw "Downflow";
    count--;
 front=(front+1) % QueueSize;    //队头指针在循环意义下加1
    return data[front];             //读取并返回出队前的队头元素，注意队头指针
 }
                                 
/*
 * 前置条件：队列已存在
 * 输    入：无
 * 功    能：读取队头元素
 * 输    出：若队列不空，返回队头元素
 * 后置条件：队列不变
 */

template <class T>
T CirQueue<T>::GetQueue( )
{  
    int i;
    if (Empty()) throw "Downflow";
    i=(front+1) % QueueSize;  //注意不要给队头指针赋值
    return data[i];
}

int main()
{
 CirQueue<string> Q;
 string x;
 while(1){
  cin>>x;
        if(x=="#") break;
  try{
   cout<<"EnQueue:";
   Q.EnQueue(x);
   cout<<x<<"\n";
  }
  catch(const char *ms)
  {
   cout<<x<<" "<<ms<<endl;
  }
 }
 while(!Q.Empty())
 {
  x=Q.DeQueue();
  cout<<"DeQueue:"<<x<<endl;
 }
 try{
  x=Q.GetQueue();
 }
 catch(const char *ms)
 {
  cout<<"GetQueue:The queue is empty,"<<ms<<endl;
 }
 return 0;
}

请实现其它未实现的成员函数，达到任务要求。

Input

Output

Sample Input

zhang sun li zhao wang xia #

Sample Output

EnQueue:zhang
EnQueue:sun
EnQueue:li
EnQueue:zhao
EnQueue:wang
EnQueue:xia Overflow
DeQueue:zhang
DeQueue:sun
DeQueue:li
DeQueue:zhao
DeQueue:wang
GetQueue:The queue is empty,Downflow

//
// Created by Legends丶Hu on 2020/2/4.
//

#include <iostream>
#include <string>

using namespace std;
const int QueueSize = 5;

template<class T>        //定义模板类CirQueue
class CirQueue {
public:
    CirQueue();                 //构造函数，置空队
    ~CirQueue();                //析构函数
    void EnQueue(T x);           //将元素x入队
    T DeQueue();                //将队头元素出队
    T GetQueue();               //取队头元素（并不删除）
    bool Empty();               //判断队列是否为空，空返回true，否则返回false
    bool Full();                 //判断队列是否为满，满返回true，否则返回false
private:
    T data[QueueSize];           //存放队列元素的数组
    int front, rear;    //队头和队尾指针，分别指向队头元素所在数组的前一下标和队尾元素的数组下标
    int count;          //记录队列中数据个数
};
template<class T>
bool CirQueue<T>::Empty() {
    return count == 0;
}
template <class T>
bool CirQueue<T>::Full() {
    return count == QueueSize;
}
template<class T>
void  CirQueue<T>::EnQueue(T x) {
    if(Full()) throw "Overflow";
    rear = (rear + 1) % QueueSize;
    count++;
    data[rear] = x;
}
template<class T>
CirQueue<T>::CirQueue() {
    front = rear = QueueSize - 1;
    count = 0;
}

template<class T>
CirQueue<T>::~CirQueue() {
}

template<class T>
T CirQueue<T>::DeQueue() {
    if (Empty()) throw "Downflow";
    count--;
    front = (front + 1) % QueueSize;    //队头指针在循环意义下加1
    return data[front];             //读取并返回出队前的队头元素，注意队头指针
}

template<class T>
T CirQueue<T>::GetQueue() {
    int i;
    if (Empty()) throw "Downflow";
    i = (front + 1) % QueueSize;  //注意不要给队头指针赋值
    return data[i];
}
//zhang sun li zhao wang xia #
int main() {
    CirQueue<string> Q;
    string x;
    while (1) {
        cin >> x;
        if (x == "#") break;
        try {
            cout << "EnQueue:";
            Q.EnQueue(x);
            cout << x << "\n";
        }
        catch (const char *ms) {
            cout << x << " " << ms << endl;
        }
    }
    while (!Q.Empty()) {
        x = Q.DeQueue();
        cout << "DeQueue:" << x << endl;
    }
    try {
        x = Q.GetQueue();
    }
    catch (const char *ms) {
        cout << "GetQueue:The queue is empty," << ms << endl;
    }
    return 0;
}