Java LinkedList自定义实现：添加返回可修改删除的节点

要满足需求，核心是让每个节点自身持有链表的前后指针引用，同时提供直接修改值和删除自身的能力，无需遍历整个链表。以下是完整实现方案：

1. 定义节点操作接口 #

沿用你给出的LinkedListNode接口：

public interface LinkedListNode<T> {
    void set(T t);
    void remove();
}

2. 自定义LinkedList实现 #

实现包含内部节点类的LinkedList，内部节点实现上述接口，同时维护链表的前驱、后继指针：

public class CustomLinkedList<T> {
    private Node<T> head;
    private Node<T> tail;
    private int size;

    // 内部节点类，实现LinkedListNode接口
    private static class Node<T> implements LinkedListNode<T> {
        private T value;
        private Node<T> prev;
        private Node<T> next;
        private CustomLinkedList<T> owner;

        public Node(T value, CustomLinkedList<T> owner) {
            this.value = value;
            this.owner = owner;
        }

        @Override
        public void set(T t) {
            this.value = t;
        }

        @Override
        public void remove() {
            // 更新前驱节点的后继引用
            if (prev != null) {
                prev.next = next;
            } else {
                // 当前是头节点，更新链表头指针
                owner.head = next;
            }

            // 更新后继节点的前驱引用
            if (next != null) {
                next.prev = prev;
            } else {
                // 当前是尾节点，更新链表尾指针
                owner.tail = prev;
            }

            // 断开当前节点的所有引用，避免内存泄漏
            this.prev = null;
            this.next = null;
            this.owner = null;

            // 更新链表元素数量
            owner.size--;
        }

        // 供外部LinkedList调用的取值方法
        public T getValue() {
            return value;
        }
    }

    // 添加元素并返回可操作的节点接口
    public LinkedListNode<T> add(T element) {
        Node<T> newNode = new Node<>(element, this);
        if (tail == null) {
            // 链表为空时，头尾指针都指向新节点
            head = newNode;
            tail = newNode;
        } else {
            // 将新节点链接到链表尾部
            tail.next = newNode;
            newNode.prev = tail;
            tail = newNode;
        }
        size++;
        return newNode;
    }

    // 可选：实现常用辅助方法
    public int size() {
        return size;
    }

    public void traverse() {
        Node<T> current = head;
        while (current != null) {
            System.out.println(current.getValue());
            current = current.next;
        }
    }
}

3. 使用示例 #

public class Main {
    public static void main(String[] args) {
        CustomLinkedList<String> list = new CustomLinkedList<>();
        LinkedListNode<String> node1 = list.add("A");
        LinkedListNode<String> node2 = list.add("B");
        LinkedListNode<String> node3 = list.add("C");

        // 修改节点值
        node2.set("Modified B");
        list.traverse(); // 输出：A、Modified B、C

        // 删除中间节点
        node2.remove();
        list.traverse(); // 输出：A、C
        System.out.println("链表长度：" + list.size()); // 输出：2
    }
}

核心逻辑说明 #

• 每个内部Node实例持有自身的前驱(prev)和后继(next)指针，以及所属的CustomLinkedList引用，删除操作直接修改相邻节点的指针，时间复杂度为O(1)，无需遍历整个链表。
• 完全依赖链表自身的指针结构实现需求，不需要额外使用HashSet存储节点。
• 实现逻辑与JDK原生LinkedList的内部节点结构类似，但对外暴露了节点的修改和删除能力。

内容的提问来源于stack exchange，提问作者Spliterash