C++练习题4

编写循环队列的构造函数和链队列的构造和析构函数，并完成两种队列的入队，出队，读取队头元素和判空操作

main.cpp

#include<iostream>
#include "Linkqueue.h"
#include"CirQueue.h"
#include <string>
#include <sstream>
#include <exception>
int main()
{
    double x;
    string input;
    try
    {
    cout<<"----------链队列----------"<<endl;
    Linkqueue<double> linkqueue;
    while(true)
    {
        cout<<"请输入入队元素值（输入000退出）：";
        cin>>input;
        std::istringstream iss(input);
        if(!(iss >> x)) throw std::runtime_error("输入不是数");
        if(input=="000") break;
        linkqueue.EnQueue(x);
    }
    cout<<"当前队列元素为：";
    linkqueue.Printqueue();

    cout<<"出队操作，出队元素:"<<linkqueue.Dequeue();
    cout<<"  当前队列元素为：";
    linkqueue.Printqueue();

    cout<<"出队操作，出队元素:"<<linkqueue.Dequeue();
    cout<<"  当前队列元素为：";
    linkqueue.Printqueue();

    cout<<"队列是否为空：";
    if(linkqueue.Empty()) cout<<"是";
    else cout<<"否";
    cout<<endl;

    cout<<"----------循环队列----------"<<endl;
    CirQueue<double> cirqueue;
    while(true)
    {
        cout<<"请输入入栈元素值（输入000退出）：";
        cin>>input;
        std::istringstream iss(input);
        if(!(iss >> x)) throw std::runtime_error("输入不是数");
        if(input=="000") break;
        cirqueue.EnQueue(x);
    }
    cout<<"当前队列元素为：";
    cirqueue.PrintQueue();

    cout<<"出队操作，出队元素:"<<cirqueue.DeQueue();
    cout<<"  当前队列元素为：";
    cirqueue.PrintQueue();

    cout<<"队列是否为空：";
    if(cirqueue.Empty()) cout<<"是";
    else cout<<"否";
    }catch(const std::runtime_error& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    return 0;
}

CirQueue.h

#ifndef CIRQUEUE_H_INCLUDED
#define CIRQUEUE_H_INCLUDED
using namespace std;
const int MaxSize=100;//长度

template <typename T>
struct CirQueue
{
    CirQueue();//构造函数
    void EnQueue(T x);//入队操作
    T DeQueue();//出队操作，将队头元素请出队列
    T GetHead();//取队头元素，不删除
    bool Empty();//判空
    void PrintQueue();//打印出来
private:
    T data[MaxSize];
    int front,rear;//队列中头和尾的下标
};

template <typename T>
CirQueue<T>::CirQueue()
{
    rear=front=MaxSize-1;//尾是真的尾（有元素），头是前一个，头指向这里是没有元素的
    //所以整个循环队列满的时候，还是留了一个位置，即头指向的位置
}

template <typename T>
void CirQueue<T>::EnQueue(T x)
{
    if((rear+1)%MaxSize==front) throw std::runtime_error("溢出");//当尾元素后一个是头元素时，说明队满了，插不进了
    rear=((rear+1)%MaxSize);
    data[rear]=x;
}

template <typename T>
T CirQueue<T>::DeQueue()
{
    if(rear==front) throw std::runtime_error("下溢");//当尾等于头时，说明说明全空了
    front =(front+1)%MaxSize;
    return data[front];
}

template <typename T>
T CirQueue<T>::GetHead()
{
    return data[(front+1)%MaxSize];
}

template <typename T>
bool CirQueue<T>::Empty()
{
    if(rear==front) return true;
    else return false;
}

template <typename T>
void CirQueue<T>::PrintQueue()
{
    int length =(rear+1)%MaxSize-(front+1)%MaxSize;
    int a=front;
    for(int i=0;i<length;i++)
    {
        cout<<data[(a+1)%MaxSize]<<" ";
        a=(a+1)%MaxSize;
    }
    cout<<endl;
}



#endif // CIRQUEUE_H_INCLUDED

Linkqueue.h

#ifndef LINKQUEUE_H_INCLUDED
#define LINKQUEUE_H_INCLUDED

using namespace std;
template <typename T>
struct Node //定义节点
{
    T data;//数据域
    Node<T> *t;//指针域
};

template <typename T>
struct Linkqueue
{
    Linkqueue();//构造函数
    void EnQueue(T x);//入队操作
    void Printqueue();//队列元素打印出来
    T Dequeue();//出队操作，请出队伍
    T GetHead();//取队头元素
    bool Empty();//判空
private:
    Node<T> *front;//队列的头结点,数据域无元素
    Node<T> *rear;//队列的最后一个结点
    int count;
};

template <typename T>
Linkqueue<T>::Linkqueue()
{
//    Node<T> *front=nullptr;
//    front->t=nullptr;
//    rear=front;
//    count=0;
      Node<T> *s=nullptr;
      s=new Node<T>;s->t=nullptr;
      front=rear=s;
}



template <typename T>
void Linkqueue<T>::EnQueue(T x)
{
    Node<T> *s=new Node<T>;
    s->data=x;s->t=nullptr;
    rear->t=s;
    rear=s;
}

template <typename T>
void Linkqueue<T>::Printqueue()
{
    Node<T> *p=front->t;
    while(p!=nullptr)
    {
        cout<<p->data<<" ";
        p=p->t;
    }
    cout<<endl;
}

template <typename T>
T Linkqueue<T>::Dequeue()
{
    if(rear==front) throw std::runtime_error("下溢");
    Node<T> *s=front->t;
    T x=s->data;
    front->t=s->t;
    if(s->t==nullptr)
    {
        rear=front;
    }
    delete s;
    return x;
}

template <typename T>
T Linkqueue<T>::GetHead()
{
    return front->t->data;
}

template <typename T>
bool Linkqueue<T>::Empty()
{
    if(front==rear) return true;
    else return false;
}



#endif // LINKQUEUE_H_INCLUDED