【慢速学数据结构】队列篇

概述

队列ADT我相信大家都很清楚，就是FIFO嘛。

这一篇，关键讲队列怎么实现。

实现

循环数组实现。

template<typename T>
class Queue_array
{
public:
    Queue_array(int maxsize = 10) : maxsize_(maxsize), 
                                    size_(0), front_(1), rear_(0)
    {
        pa_ = new T[maxsize_];// 初始化数组，默认大小为10
    }
    virtual ~Queue_array()
    {
        delete[] pa_;
    }

public:
    void push(const T& x)
    {
        if (isFull())
            return;

        size_++;
        rear_++;
        rear_ %= maxsize_;// 让rear在将要越界的时候，回到0，从而实现循环

        *(pa_ + rear_) = x;
    }
    void pop()
    {
        size_--;
        front_++;
        front_ %= 10;// 不要忘了，这里也要加
    }
    const T getFront()
    {
        return *(pa_ + front_);
    }
    const int getSize() const
    {
        return size_;
    }
    bool isEmpty() const
    {
        return size == 0;
    }
    bool isFull() const
    {
        return size_ == maxsize_;
    }

private:
    int front_, rear_;
    T* pa_;
    int size_;
    int maxsize_;
};

链表实现

template<typename T>
class Queue_list {
public:
    typedef struct list {
        T data;
        list *next;
        list(T x) : data(x), next(nullptr) {}
    } ListNode;

    Queue_list(int maxsize = 10) : size_(0), maxsize_(maxsize) {
        front_ = rear_ = new ListNode(0);// 初始化，front和rear都指向同一个结点
    }

    virtual ~Queue_list() {
        while( front_ != rear_) {
            ListNode* t = front_->next;
            delete front_;
            front_ = t;
        }
        delete rear_;
    };
public:
    // 插到rear现在所在的位置，并且新增一个结点让rear指向它
    void push( const T& x) {
        size_++;
        rear_->data = x;
        rear_->next = new ListNode(0);
        rear_ = rear_->next;
    }

    // 删除front现在指向的结点，将front指向下一个结点
    void pop() {
        size_--;
        ListNode *t = front_;
        front_ = front_->next;
        delete t;
    }

    const T getFront() {
        return front_->data;
    }

    const int getSize() const {
        return size_;
    }

    bool isEmpty() const {
        return front == rear;
    }

    // 链表实现可以不考虑队列满的情况
private:
    ListNode *front_, *rear_;
    int size_;
    int maxsize_;
};

测试用例：

int main() {
    {
        Queue_list<int> q;
        for(auto i = 0; i<10; i++)
            q.push(i);
        q.pop();
        assert(9 == q.getSize());
        assert(1 == q.getFront());
        q.push(10);
        q.pop();
        assert(2 == q.getFront());
    }

    {
        Queue_array<int> q;
        for(auto i = 0; i<10; i++)
            q.push(i);
        q.pop();
        assert(9 == q.getSize());
        assert(1 == q.getFront());
        q.push(10);
        q.pop();
        assert(2 == q.getFront());
    }


    std::cout << "All test cases pass";
    return 0;
}

应用

来学习一下STL里的deque，cppreference里对它的大概描述是：

deque(double end queue 双端队列)，随机访问时间O(1)，插入头和尾结点的时间是O(1)，普通插入的时间是O(N)。它的存储是由多个固定大小的数组组成，而且在动态扩充大小的时候效率很高，不会像vector那样，将所有的内容重新复制到新的内存中。