Java原地反转单链表（O(1)空间）：代码实现与边缘问题咨询

核心问题修复：head与tail的重分配 #

你的三指针方案逻辑可行，但反转后必须交换原head和tail的引用，同时要针对性处理空链表、单节点等边缘场景，避免空指针异常。

完整修正后的代码实现 #

以下是包含全场景处理的链表类及反转方法：

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

    private static class Node<T> {
        T data;
        Node<T> next;
        Node(T data) {
            this.data = data;
            this.next = null;
        }
    }

    // 原地反转方法
    public void reverse() {
        // 空链表或单节点链表直接返回，无需操作
        if (head == null || head.next == null) {
            return;
        }

        Node<T> prev = null;
        Node<T> current = head;
        Node<T> next;

        // 遍历反转节点指针
        while (current != null) {
            next = current.next; // 暂存下一个节点
            current.next = prev; // 反转当前节点的next指针
            prev = current;      // prev指针向后移动
            current = next;      // current指针向后移动
        }

        // 交换head和tail引用
        Node<T> temp = head;
        head = tail;
        tail = temp;
    }

    // 辅助方法：尾部添加节点（用于测试）
    public void add(T data) {
        Node<T> newNode = new Node<>(data);
        if (head == null) {
            head = newNode;
            tail = newNode;
        } else {
            tail.next = newNode;
            tail = newNode;
        }
        size++;
    }

    // 辅助方法：打印链表（用于测试）
    public void printList() {
        Node<T> current = head;
        while (current != null) {
            System.out.print(current.data + " -> ");
            current = current.next;
        }
        System.out.println("null");
    }
}

边缘情况处理说明 #

• 空链表：head == null时直接返回，无任何操作，避免空指针。
• 单节点链表：head.next == null时直接返回，反转后链表结构不变，无需修改head和tail。
• 多节点链表：遍历结束后，prev指向原链表的最后一个节点（即新的head），原head变为新的tail，交换两者引用即可完成结构修正。

内存泄漏问题说明 #

Java基于垃圾回收（GC）机制管理内存，只要对象无可达引用就会被自动回收：

• 反转过程仅修改节点的next指针，未创建新节点，也没有遗留无引用的节点。
• 反转后所有节点仍通过head->next的链路保持可达，不会出现内存泄漏。
• 若外部持有原链表节点的引用，反转后这些引用的指向不会改变，但这属于业务逻辑层面的问题，并非反转方法导致的内存泄漏。

测试用例验证 #

用以下代码可验证所有场景：

public class Main {
    public static void main(String[] args) {
        // 测试空链表
        CustomLinkedList<Integer> emptyList = new CustomLinkedList<>();
        emptyList.reverse();
        emptyList.printList(); // 输出：null

        // 测试单节点链表
        CustomLinkedList<Integer> singleNodeList = new CustomLinkedList<>();
        singleNodeList.add(1);
        singleNodeList.reverse();
        singleNodeList.printList(); // 输出：1 -> null

        // 测试三节点链表
        CustomLinkedList<Integer> threeNodeList = new CustomLinkedList<>();
        threeNodeList.add(1);
        threeNodeList.add(2);
        threeNodeList.add(3);
        threeNodeList.reverse();
        threeNodeList.printList(); // 输出：3 -> 2 -> 1 -> null
    }
}

内容的提问来源于stack exchange，提问作者CRISTIAN JOSUE FLORES PLEITEZ