Java双向链表指定索引节点删除操作详解

public class Node<T> {
    T data; // 存储节点数据
    Node<T> next; // 指向下一个节点
    Node<T> previous; // 指向上一个节点

    public Node(T data) {
        this.data = data;
        this.next = null;
        this.previous = null;
    }

    @Override
    public String toString() {
        return data.toString();
    }
}

public class DoublyLinkedList<T extends Comparable<T>> {
    protected Node<T> head;
    protected Node<T> tail;
    int size = 0;

    public DoublyLinkedList() {
        this.head = null;
        this.tail = null;
    }

    /**
     * 在链表末尾添加一个新节点
     * @param data 要添加的数据
     * @return 新添加的节点
     */
    public Node<T> append(T data) {
        Node<T> newNode = new Node<>(data);
        if (head == null) { // 链表为空时
            head = newNode;
            tail = newNode;
        } else { // 链表不为空时
            newNode.previous = tail;
            tail.next = newNode;
            tail = newNode;
        }
        size++;
        return newNode;
    }

    // toString 方法用于方便地打印链表内容
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("[%d]: ", size));
        Node<T> current = head;
        while (current != null) {
            sb.append(current.data);
            if (current.next != null) {
                sb.append(" <-> ");
            }
            current = current.next;
        }
        return sb.toString();
    }
}

public void delete(int location) throws IllegalArgumentException {
    // 1. 参数校验：检查链表是否为空，以及索引是否越界
    if (head == null || location < 0 || location >= size) {
        throw new IllegalArgumentException("无效的索引位置或链表为空。");
    }

    // ... 后续删除逻辑
}

public void delete(int location) throws IllegalArgumentException {
    // 1. 参数校验
    if (head == null || location < 0 || location >= size) {
        throw new IllegalArgumentException("无效的索引位置或链表为空。");
    }

    // 2. 处理删除链表中唯一节点的情况
    if (size == 1 && location == 0) {
        head = null;
        tail = null;
    } 
    // 3. 处理删除头节点的情况 (链表有多个节点)
    else if (location == 0) {
        head = head.next; // 新的头节点是原头节点的下一个
        if (head != null) { // 确保新头节点不为空
            head.previous = null; // 新头节点的previous指向null
        }
        // 如果删除后只剩一个节点（原有两个节点），则新的head也是tail
        // 实际上，如果head.next是null，那么head就是null，tail也应该为null，这在size==1时已处理
        // 如果head.next不为null，且size-1 == 0，即原size为1，已处理
        // 如果原size为2，location=0，head变为原tail，此时head即是tail
        if (size == 2) { // 原始链表有两个节点，删除头节点后，剩下的一个节点既是头也是尾
            tail = head;
        }
    } 
    // 4. 处理删除尾节点的情况 (链表有多个节点)
    else if (location == size - 1) {
        tail = tail.previous; // 新的尾节点是原尾节点的前一个
        if (tail != null) { // 确保新尾节点不为空
            tail.next = null; // 新尾节点的next指向null
        }
        // 注意：如果原size为1，location=0，已在上面处理
        // 如果原size为2，location=1，删除尾节点后，剩下的一个节点既是头也是尾
        if (size == 2) { // 原始链表有两个节点，删除尾节点后，剩下的一个节点既是头也是尾
            head = tail; // head也指向这个唯一的节点
        }
    } 
    // 5. 处理删除中间节点的情况
    else {
        Node<T> current = head;
        // 遍历到要删除的节点
        for (int i = 0; i < location; i++) {
            current = current.next;
        }
        // current 现在指向要删除的节点
        // 调整前一个节点的next指针
        current.previous.next = current.next;
        // 调整后一个节点的previous指针
        current.next.previous = current.previous;
    }
    size--; // 链表大小减一
}

public void delete(int location) throws IllegalArgumentException {
    if (head == null || location < 0 || location >= size) {
        throw new IllegalArgumentException("无效的索引位置或链表为空。");
    }

    if (size == 1) { // 链表中只有一个节点
        head = null;
        tail = null;
    } else if (location == 0) { // 删除头节点
        head = head.next;
        head.previous = null;
    } else if (location == size - 1) { // 删除尾节点
        tail = tail.previous;
        tail.next = null;
    } else { // 删除中间节点
        Node<T> current = head;
        for (int i = 0; i < location; i++) { // 遍历到要删除的节点
            current = current.next;
        }
        // current 是要删除的节点
        current.previous.next = current.next;
        current.next.previous = current.previous;
    }
    size--; // 链表大小减一
}

class Student implements Comparable<Student> {
    private static int counter;
    private int id;

    public Student() {
        id = ++counter; // 每次创建新学生时，ID自动递增
    }

    @Override
    public int compareTo(Student o) {
        return id - o.id; // 根据ID比较学生
    }

    @Override
    public boolean