队列实现

队列是一个先进先出的算法，正好和之前的堆栈相对应，堆栈是先进后出，他们两个在不同的问题上都有自己各自的用处，在这里就是用C++实现自己的队列，并扩展了一些函数来供我们使用。好了，话不多了，直接上代码的实现部分：

//============================================================================
// Name        : Queue.cpp
// Author      : 陈洪波
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include "Exception.h"
#include <iostream>
using namespace std;

template<class T>
class Queue {
public:
    Queue(int MaxQueueSize = 10);
    ~Queue() {
        delete[] queue;
    }
    /* 判断队列是否为空 */
    bool IsEmpty() {
        return front == rear;
    }
    /* 判断是否已满 */
    bool IsFull() {
        return ((rear + 1) % MaxSize == front) ? 1 : 0;
    }
    /* 返回第一个元素 */
    T First() const;
    /* 返回队尾元素 */
    T Last() const;
    /* 添加元素 */
    Queue<T>& Add(const T& x);
    /* 删除元素,将删除的元素保存在x中 */
    Queue<T>& Delete(T& x);

    int GetMax() {
        return MaxSize - 1;
    }

//=============新增======================//
    /* 获取队列中的元素的数目 */
    int Size() {
        return rear;
    }
    /* 输入一个队列 */
    Queue<T>& init(T* t, int n);
    /* 输出一个队列 */
    void Output(ostream& out) const;
//=============新增======================//

//=============新增二======================//
    /* 将一个队列拆分成两个，1,3,5。。位置的一个，另外一个 */
    void split(Queue<T> &x, Queue<T>& y);
    Queue<T>& merge(Queue<T>& x, Queue<T>& y);
//=============新增二 ======================//

private:
    int front; //指向第一个元素位置的上一个位置
    int rear; //指向最后一个元素
    int MaxSize; //最大元素数量
    T *queue;
};

template<class T>
Queue<T>::Queue(int MaxQueueSize) {
    //创建一个容量为MaxQueueSize的空队列。
    MaxSize = MaxQueueSize + 1;
    queue = new T[MaxSize];
    rear = front = 0;
}

template<class T>
T Queue<T>::First() const {
    if (IsEmpty())
        throw OutOfBounds();

    return queue[(front + 1) % MaxSize];
}

template<class T>
T Queue<T>::Last() const {
    if (IsEmpty())
        throw OutOfBounds();

    return queue[rear];
}

template<class T>
Queue<T>& Queue<T>::Add(const T& x) {
    if (IsFull())
        throw OutOfBounds();

    rear = (rear + 1) % MaxSize;

    queue[rear] = x;

    return *this;
}

template<class T>
Queue<T>& Queue<T>::Delete(T& x) {
    if (IsEmpty())
        throw OutOfBounds();

    front = (front + 1) % MaxSize;

    x = queue[front];

    return *this;
}

//=============新增======================//
template<class T>
Queue<T>& Queue<T>::init(T* t, int n) {
    if (n > MaxSize - 1)
        throw OutOfBounds();

    int i = 0;
    for (i = 0; i < n; i++)
        this->Add(t[i]);

    return *this;
}

template<class T>
void Queue<T>::Output(ostream& out) const {
    for (int i = front + 1; i <= rear; i++)
        cout << queue[i] << " ";
    cout << endl;
}

template<class T>
ostream& operator<<(ostream& out, const Queue<T>& x) {
    x.Output(out);

    return out;
}

//=============新增======================//

//=============新增二 ======================//
template<class T>
void Queue<T>::split(Queue<T> &x, Queue<T>& y) {

    int i = 1;
    while (!IsEmpty()) {
        T temp;
        this->Delete(temp);

        if(i % 2 == 0){
            y.Add(temp);
        }else{
            x.Add(temp);
        }

        i++;
    }

}

template<class T>
Queue<T>& Queue<T>::merge(Queue<T>& x, Queue<T>& y) {
    if (x.Size() + y.Size() > this->GetMax())
        throw OutOfBounds();

    while ((!x.IsEmpty()) || (!y.IsEmpty())) {
        T a, b;

        if (!x.IsEmpty()) {
            x.Delete(a);
            this->Add(a);
        }
        if (!y.IsEmpty()) {
            y.Delete(b);
            this->Add(b);
        }
    }

    return *this;
}

int main() {

    /*======================代码测试===============================
     Queue<int> q(5);

     q.Add(3);
     q.Add(2);

     int x;
     q.Delete(x);

     cout << x << endl;
     =========================================================*/

    /*=============新增======================//
     Queue<int> q1(10);
     int temp[] = {1,2,3,4,5,6,7,8,9,10};
     q1.init(temp,10);
     cout << q1;
     //=============新增======================*/

    /*=============新增二======================//
     Queue<int> q1(10);
     Queue<int> x(5);
     x.Add(1);
     x.Add(2);
     x.Add(3);
     x.Add(4);
     x.Add(5);
     Queue<int> y(5);
     y.Add(6);
     y.Add(7);
     y.Add(8);
     y.Add(9);
     y.Add(10);

     q1.merge(x,y);
     cout << q1;
     //=============新增二======================*/

    Queue<int> q1(10);
    Queue<int> x(5);
    q1.Add(1);
    q1.Add(2);
    q1.Add(3);
    q1.Add(4);
    q1.Add(5);
    Queue<int> y(5);
    q1.Add(6);
    q1.Add(7);
    q1.Add(8);
    q1.Add(9);
    q1.Add(10);

    q1.split(x,y);
    cout << x;
    return 0;
}