FIFO：带尾指针的循环双链表

FIFO 先进先出

622. 设计循环队列

设计一个循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

设计

要求能够在头进行删除，尾进行插入==>带尾指针循环双链表

实现

struct Node
{ // 链表结点数据结构
    int val;
    Node *next;
    Node *prev;

    Node() : next(nullptr), prev(nullptr) {}
    Node(int _val) : val(_val), next(nullptr), prev(nullptr) {}
    Node(int _val, Node *_next) : val(_val), next(_next), prev(nullptr) {}
};

struct LinkedList
{                 // 链表数据结构
    Node *tail;   // 虚拟尾指针
    int capacity; // 容量
    int size;     // 当前大小
    LinkedList(int k) : tail(new Node()), capacity(k), size(0)
    {
        tail->next = tail;
        tail->prev = tail;
    }

    Node *getFront()
    {
        return tail->next;
    }

    Node *getRear()
    {
        return tail->prev;
    }

    // 插入尾部（tail->prev）
    void addTail(Node *cur)
    {
        cur->next = tail;
        cur->prev = tail->prev;
        tail->prev->next = cur;
        tail->prev = cur;
        ++size;
    }

    // 删除头部（tail->next）
    Node *delHead()
    {
        Node *rst = tail->next;
        rst->next->prev = tail;
        tail->next = tail->next->next;
        --size;
        return rst;
    }

    bool empty()
    {
        return size == 0;
    }

    bool full()
    {
        return size == capacity;
    }
};

class MyCircularQueue
{
private:
    LinkedList q;

public:
    MyCircularQueue(int k) : q(k) {}

    // 插入
    bool enQueue(int value)
    {
        if (q.full())
        { // 满了无法插入，size == capacity，包括了初始容量0的情况
            return false;
        }
        Node *cur = new Node(value);
        q.addTail(cur);
        return true;
    }

    // 删除
    bool deQueue()
    {
        if (q.empty())
        {
            return false;
        }
        Node *cur = q.delHead();
        delete cur;
        return true;
    }

    int Front()
    {
        if (q.empty())
        {
            return -1;
        }
        return q.getFront()->val;
    }

    int Rear()
    {
        if (q.empty())
        {
            return -1;
        }
        return q.getRear()->val;
    }

    bool isEmpty()
    {
        return q.empty();
    }

    bool isFull()
    {
        return q.full();
    }
};

简单写法：

struct Node
{
    int val_;
    Node *prev_;
    Node *next_;

    Node() : val_(0), prev_(nullptr), next_(nullptr) {}
    Node(int _val) : val_(_val), prev_(nullptr), next_(nullptr) {}
    Node(int _val, Node *_prev, Node *_next) : val_(_val), prev_(_prev), next_(_next) {}
};

class MyCircularQueue
{
private:
    int capcity_;
    int size_;
    Node *dummyTail_;

public:
    MyCircularQueue(int k) : capcity_(k), size_(0), dummyTail_(new Node())
    {
        dummyTail_->next_ = dummyTail_;
        dummyTail_->prev_ = dummyTail_;
    }

    bool enQueue(int value)
    {
        if (isFull())
        {
            return false;
        }
        Node *tmp = new Node(value, dummyTail_->prev_, dummyTail_);
        dummyTail_->prev_->next_ = tmp;
        dummyTail_->prev_ = tmp;
        size_++;
        return true;
    }

    bool deQueue()
    {
        if (isEmpty())
        {
            return false;
        }
        Node *tmp = dummyTail_->next_;
        dummyTail_->next_ = tmp->next_;
        tmp->next_->prev_ = dummyTail_;
        size_--;
        delete tmp;
        return true;
    }

    int Front()
    {
        if (isEmpty())
        {
            return -1;
        }
        return dummyTail_->next_->val_;
    }

    int Rear()
    {
        if (isEmpty())
        {
            return -1;
        }
        return dummyTail_->prev_->val_;
    }

    bool isEmpty() { return size_ == 0; }

    bool isFull() { return capcity_ == size_; }
};