C++中的双向链表(未分配要释放的指针)

class Node {
public:
    int data;
    Node* prev;
    Node* next;
};

class DoublyLinkedList {
private:
    Node* head;
    Node* tail;

public:
    // 构造函数和析构函数
    DoublyLinkedList();
    ~DoublyLinkedList();

    // 插入操作
    void insertFront(int value);    // 在链表头部插入节点
    void insertBack(int value);     // 在链表尾部插入节点
    void insertAfter(int key, int value);    // 在指定节点后插入节点

    // 删除操作
    void deleteNode(int value);     // 删除指定值的节点
    void deleteFront();             // 删除头节点
    void deleteBack();              // 删除尾节点

    // 遍历操作
    void displayForward();          // 正向遍历链表
    void displayBackward();         // 反向遍历链表
};

DoublyLinkedList::DoublyLinkedList() {
    head = NULL;
    tail = NULL;
}

DoublyLinkedList::~DoublyLinkedList() {
    Node* current = head;
    while (current != NULL) {
        Node* next = current->next;
        delete current;
        current = next;
    }
}

void DoublyLinkedList::insertFront(int value) {
    Node* newNode = new Node;
    newNode->data = value;
    newNode->prev = NULL;
    newNode->next = head;
    if (head != NULL) {
        head->prev = newNode;
    }
    head = newNode;
    if (tail == NULL) {
        tail = newNode;
    }
}

void DoublyLinkedList::insertBack(int value) {
    Node* newNode = new Node;
    newNode->data = value;
    newNode->prev = tail;
    newNode->next = NULL;
    if (tail != NULL) {
        tail->next = newNode;
    }
    tail = newNode;
    if (head == NULL) {
        head = newNode;
    }
}

void DoublyLinkedList::insertAfter(int key, int value) {
    Node* current = head;
    while (current != NULL && current->data != key) {
        current = current->next;
    }
    if (current != NULL) {
        Node* newNode = new Node;
        newNode->data = value;
        newNode->prev = current;
        newNode->next = current->next;
        if (current->next != NULL) {
            current->next->prev = newNode;
        } else {
            tail = newNode;
        }
        current->next = newNode;
    }
}

void DoublyLinkedList::deleteNode(int value) {
    Node* current = head;
    while (current != NULL && current->data != value) {
        current = current->next;
    }
    if (current != NULL) {
        if (current->prev != NULL) {
            current->prev->next = current->next;
        } else {
            head = current->next;
        }
        if (current->next != NULL) {
            current->next->prev = current->prev;
        } else {
            tail = current->prev;
        }
        delete current;
    }
}

void DoublyLinkedList::deleteFront() {
    if (head != NULL) {
        Node* temp = head;
        head = head->next;
        if (head != NULL) {
            head->prev = NULL;
        } else {
            tail = NULL;
        }
        delete temp;
    }
}

void DoublyLinkedList::deleteBack() {
    if (tail != NULL) {
        Node* temp = tail;
        tail = tail->prev;
        if (tail != NULL) {
            tail->next = NULL;
        } else {
            head = NULL;
        }
        delete temp;
    }
}

void DoublyLinkedList::displayForward() {
    Node* current = head;
    while (current != NULL) {
        cout << current->data << " ";
        current = current->next;
    }
    cout << endl;
}

void DoublyLinkedList::displayBackward() {
    Node* current = tail;
    while (current != NULL) {
        cout << current->data << " ";
        current = current->prev;
    }
    cout << endl;
}