用C++语言实现一个双向循环链表

双向循环链表是一种链式存储结构，每个节点包含一个指向前驱节点和后继节点的指针。在C++语言中，可以通过定义一个双向循环链表类来实现该数据结构。

以下是一个简单的双向循环链表类的实现：

class Node {
public:
    int value;
    Node* prev;
    Node* next;
    Node(int v) : value(v), prev(nullptr), next(nullptr) {}
};

class DoublyLinkedList {
public:
    DoublyLinkedList() : head(nullptr), tail(nullptr), size(0) {}

    ~DoublyLinkedList() {
        while (head != nullptr) {
            Node* temp = head;
            head = head->next;
            delete temp;
        }
        tail = nullptr;
        size = 0;
    }

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

    int length() const {
        return size;
    }

    void push_front(int v) {
        Node* newNode = new Node(v);
        if (empty()) {
            head = tail = newNode;
        } else {
            newNode->next = head;
            head->prev = newNode;
            head = newNode;
        }
        tail->next = head;
        head->prev = tail;
        size++;
    }

    void push_back(int v) {
        if (empty()) {
            push_front(v);
        } else {
            Node* newNode = new Node(v);
            newNode->prev = tail;
            tail->next = newNode;
            tail = newNode;
            tail->next = head;
            head->prev = tail;
            size++;
        }
    }

    void pop_front() {
        if (size == 1) {
            delete head;
            head = tail = nullptr;
            size = 0;
        } else if (!empty()) {
            Node* temp = head;
            head = head->next;
            head->prev = tail;
            tail->next = head;
            delete temp;
            size--;
        }
    }

    void pop_back() {
        if (size == 1) {
            pop_front();
        } else if (!empty()) {
            Node* temp = tail;
            tail = tail->prev;
            tail->next = head;
            head->prev = tail;
            delete temp;
            size--;
        }
    }

private:
    Node* head;
    Node* tail;
    int size;
};

该类包含两个私有成员变量 `head` 和 `tail`，分别指向链表的头节点和尾节点，以及一个整型变量 `size` 表示链表的长度。类的公有成员函数包括：

- `empty()`：判断链表是否为空。
- `length()`：返回链表的长度。
- `push_front(int v)`：在链表头部插入一个值为 `v` 的节点。
- `push_back(int v)`：在链表尾部插入一个值为 `v` 的节点。
- `pop_front()`：删除链表头部的节点。
- `pop_back()`：删除链表尾部的节点。

注意，在插入第一个节点时，需要将 `head` 和 `tail` 都指向该节点，并且将该节点的 `next` 和 `prev` 指针都指向自身。在删除最后一个节点时，需要特别处理，即将 `head` 和 `tail` 都置为 `nullptr`。

可以使用以下代码进行测试：

#include <iostream>

int main() {
    DoublyLinkedList list;
    std::cout << "Empty: " << list.empty() << std::endl;
    std::cout << "Length: " << list.length() << std::endl;

    list.push_back(1);
    list.push_front(2);
    list.push_back(3);
    std::cout << "Empty: " << list.empty() << std::endl;
    std::cout << "Length: " << list.length() << std::endl;

    list.pop_front();
    list.pop_back();
    std::cout << "Empty: " << list.empty() << std::endl;
    std::cout << "Length: " << list.length() << std::endl;

    return 0;
}