双项链表的使用

介绍

双向链表是一种链表数据结构，每个节点包含两个指针，一个指向前一个节点，一个指向后一个节点。这种结构使得双向链表可以从任意一个节点开始向前或向后遍历。
案例

java 复制代码
class DoublyListNode {
    int val; // 当前节点的值
    DoublyListNode prev; // 指向前一个节点的指针
    DoublyListNode next; // 指向后一个节点的指针

    DoublyListNode(int val) {
        this.val = val;
        this.prev = null;
        this.next = null;
    }
}

public class DoublyLinkedList {
    private DoublyListNode head; // 头节点
    private DoublyListNode tail; // 尾节点

    // 添加元素到双向链表的头部
    public void addToFront(int val) {
        DoublyListNode newNode = new DoublyListNode(val);
        if (head == null) { // 如果链表为空
            head = newNode;
            tail = newNode;
        } else {
            newNode.next = head; // 新节点的下一个节点指向当前头节点
            head.prev = newNode; // 当前头节点的前一个节点指向新节点
            head = newNode; // 更新头节点
        }
    }

    // 添加元素到双向链表的尾部
    public void addToBack(int val) {
        DoublyListNode newNode = new DoublyListNode(val);
        if (tail == null) { // 如果链表为空
            head = newNode;
            tail = newNode;
        } else {
            newNode.prev = tail; // 新节点的前一个节点指向当前尾节点
            tail.next = newNode; // 当前尾节点的下一个节点指向新节点
            tail = newNode; // 更新尾节点
        }
    }

    // 从双向链表中删除指定元素
    public void delete(int val) {
        DoublyListNode current = head;
        while (current != null) {
            if (current.val == val) {
                if (current == head) { // 如果要删除的节点是头节点
                    head = head.next; // 更新头节点
                    if (head != null) head.prev = null; // 如果头节点存在，将其前一个节点置为null
                } else if (current == tail) { // 如果要删除的节点是尾节点
                    tail = tail.prev; // 更新尾节点
                    if (tail != null) tail.next = null; // 如果尾节点存在，将其下一个节点置为null
                } else { // 如果要删除的节点在链表中间
                    current.prev.next = current.next; // 将当前节点的前一个节点的下一个节点指向当前节点的下一个节点
                    current.next.prev = current.prev; // 将当前节点的下一个节点的前一个节点指向当前节点的前一个节点
                }
                return; // 删除完成，退出循环
            }
            current = current.next; // 继续遍历下一个节点
        }
    }

    // 反转双向链表
    public void reverse() {
        DoublyListNode temp = null;
        DoublyListNode current = head;

        // 交换每个节点的prev和next指针
        while (current != null) {
            temp = current.prev; // 临时保存当前节点的前一个节点
            current.prev = current.next; // 当前节点的prev指针指向当前节点的next节点
            current.next = temp; // 当前节点的next指针指向当前节点的前一个节点
            current = current.prev; // 当前节点向前移动
        }

        // 更新头部和尾部节点
        if (temp != null) {
            head = temp.prev; // 更新头节点
            tail = current; // 更新尾节点，此时current为null
        }
    }

    // 从头到尾遍历双向链表
    public void traverseForward() {
        DoublyListNode current = head;
        while (current != null) {
            System.out.print(current.val + " "); // 输出当前节点的值
            current = current.next; // 继续遍历下一个节点
        }
        System.out.println(); // 输出换行，用于美观
    }

    // 从尾到头遍历双向链表
    public void traverseBackward() {
        DoublyListNode current = tail;
        while (current != null) {
            System.out.print(current.val + " "); // 输出当前节点的值
            current = current.prev; // 继续遍历前一个节点
        }
        System.out.println(); // 输出换行，用于美观
    }
}