隊列（Queue）-- 數組實現（C++ ）

什麼是隊列？

隊列是一種先入先出的數據結構（FIFO），只允許在前端(front)刪除，在後端(rear)插入。

那麼怎麼實現隊列呢？

數組實現

變量

前端： front

後端： rear

存儲數組： queue

容量： capacity

功能

構造隊列：Queue

析構隊列：~Queue

入隊：enqueue

出隊：dequeue

判空：isEmpty

判滿：isFull

大小：capacity

查看隊首：front

以int爲數據，類代碼：

class Queue {
public:
    Queue(int c = 10);
    ~Queue();
    bool enqueue(int data);
    int dequeue();
    int front();
    bool isEmpty();
    bool isFull();
    int size();
private:
    int *queue_;
    int front_;
    int rear_;
    int capacity_;
};

使用模板類造後：

template <typename T>
class Queue {
public:
    Queue(int c = 10);
    ~Queue();
    bool enqueue(T data);
    T dequeue();
    T front();
    bool isEmpty();
    bool isFull();
    int size();
private:
    T *queue_;
    int front_;
    int rear_;
    int capacity_;
};

模板類接口實現：

用數組是現實時常實現爲循環隊列，以便實現O(1)入隊和出隊，使空間合理被應用。

空隊列： front == rear

滿隊列： (rear + 1) % size == front （犧牲一個位置）

template <typename T>
Queue<T>::Queue(int c):
    capacity_(c),
    front_(0),
    rear_(0),
    queue_(NULL)
{
    queue_ = new T [c];
    std::cout << "capacity:" << c << std::endl;
}

template <typename T>
Queue<T>::~Queue()
{
    if(queue_) {
        delete [] queue_;
    }
}

template <typename T>
bool Queue<T>::enqueue(T data)
{
    if(isFull()) {
        return false;
    }

    queue_[rear_] = data;
    rear_ = (rear_ + 1) % capacity_;

    return true;
}

template <typename T>
T Queue<T>::dequeue()
{
    T data;

    if(isEmpty()) {
        throw std::out_of_range("Queue::dequeue() - Empty queue");
    }

    data = queue_[front_];
    front_ = (front_ + 1) % capacity_;

    return data;
}

template <typename T>
T Queue<T>::front()
{
    if(isEmpty()) {
        throw std::out_of_range("Queue::front() - Empty queue");
    }

    return queue_[front_];
}

template <typename T>
bool Queue<T>::isEmpty()
{
    return (front_ == rear_);
}

template <typename T>
bool Queue<T>::isFull()
{
    return (((rear_+1) % capacity_) == front_);
}

template <typename T>
int Queue<T>::size()
{
    return ((rear_ -  front_ + capacity_) % capacity_);
}