【線性表（三）】：隊列之普通隊列

一、定義隊列的基類

template <class T>
class Queue
{
public:
    virtual  ~Queue(){}
    //隊列是否爲空
    virtual bool empty() = 0;
    //隊列的大小
    virtual size_t size() =0;
    //返回隊首元素
    virtual  T front() = 0;
    //返回隊尾元素
    virtual T back() = 0;
    //隊首彈出元素
    virtual T pop() = 0;
    //隊尾添加元素
    virtual void push(const T &value) = 0;
};

二、隊列的數組實現

template <class T>
class ArrayQueue:public Queue<T>
{
public:
    ArrayQueue()
            :capacity_(10),
             ptr_(shared_ptr<T>(new T[10],[](T *p){delete[] p;})),
             size_(0){}
    ArrayQueue(const size_t &capacity);
    ~ArrayQueue(){}

    //隊列是否爲空
    bool empty(){return size_==0;}
    //隊列的大小
    size_t size(){return size_;}
    //隊列容量大小
    size_t max_size(){return capacity_;}

    //返回隊首元素
    T front();
    //返回隊尾元素
    T back();
    //隊首彈出元素
    T pop();
    //隊尾添加元素
    void push(const T &value);

    //打印隊列
    void print();
private:
    void expend_capacity(const size_t &new_capacity);//動態擴容
private:
    shared_ptr<T> ptr_;
    size_t size_;
    size_t capacity_;
};

template <class T>
ArrayQueue<T>::ArrayQueue(const size_t &capacity)
{
    if(capacity_<=0){
        cout<<"queue capacity must >0"<<endl;
        exit(0);
    }

    capacity_=capacity;
    ptr_=shared_ptr<T>(new T[capacity_],[](T *p){delete[] p;});
    size_=0;
}

template <class T>
T ArrayQueue<T>::front()
{
    return *ptr_.get();
}

template <class T>
T ArrayQueue<T>::back()
{
    return *(ptr_.get()+size_-1);
}

template <class T>
T ArrayQueue<T>::pop()
{
    T value=*ptr_.get();
    copy(ptr_.get()+1,ptr_.get()+size_,ptr_.get());
    --size_;

    return value;
}

template <class T>
void ArrayQueue<T>::expend_capacity(const size_t &new_capacity)
{
    shared_ptr<T> temp(new T[new_capacity],[](T *p){delete[] p;});
    copy(ptr_.get(),ptr_.get()+size_,temp.get());
    ptr_.swap(temp);
    temp.reset();
}

template <class T>
void ArrayQueue<T>::push(const T &value)
{
    if(size_+1>capacity_){
        capacity_*=2;
        expend_capacity(capacity_);
    }

    *(ptr_.get()+size_)=value;
    ++size_;
}

template <class T>
void ArrayQueue<T>::print()
{
    for(int i=0;i<size_;++i){
        cout<<*(ptr_.get()+i)<<" ";
    }
    cout<<endl;
}

三、隊列的鏈表實現

template <class T>
class ListQueue:public Queue<T>,
                public SingleList<T>
{
public:
    ListQueue():head_(SingleList<T>()){};
    ~ListQueue(){};

    //隊列是否爲空
    bool empty() {return head_.empty();}
    //隊列的大小
    size_t size(){return head_.size();}

    //返回隊首元素
    T front();
    //返回隊尾元素
    T back();
    //隊首彈出元素
    T pop();
    //隊尾添加元素
    void push(const T &value);

    //打印隊列
    void print();
private:
    SingleList<T> head_;
};

template <class T>
T ListQueue<T>::front()
{
    return head_.get(0);
}

template <class T>
T ListQueue<T>::back()
{
    return head_.get(size()-1);
}

template <class T>
T ListQueue<T>::pop()
{
    return head_.erase(0);
}

template <class T>
void ListQueue<T>::push(const T &value)
{
    head_.insert(size(),value);
}

template <class T>
void ListQueue<T>::print()
{
    head_.print();
}

參考鏈接：

隊列的實現——c++