Java 反转链表及头插法尾插法代码及图解

Java实现链表反转的两种经典方法（迭代法和递归法）

一、迭代法实现

‌核心思想‌：通过三个指针（prev/current/next）逐步修改节点指向
‌图解流程‌：

原链表：1 → 2 → 3 → null  
步骤1：prev=null, current=1 → 1.next=null → prev=1, current=2  
步骤2：prev=1, current=2 → 2.next=1 → prev=2, current=3  
步骤3：prev=2, current=3 → 3.next=2 → prev=3, current=null  
结果：3 → 2 → 1 → null

public class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

public ListNode reverseList(ListNode head) {
    ListNode prev = null;
    ListNode current = head;
    while (current != null) {
        ListNode nextTemp = current.next; // 暂存下一节点
        current.next = prev; // 反转指针
        prev = current;      // prev前移
        current = nextTemp;  // current前移
    }
    return prev; // 新头节点
}

时间复杂度O(n)，空间复杂度O(1)

二、递归法实现

‌核心思想‌：递归到链表末端，回溯时逐节点反转6
‌递归过程‌：

递：1 → 2 → 3 → null  
归：3.next=2 → 2.next=1 → 1.next=null

public ListNode reverseList(ListNode head) {
    if (head == null || head.next == null) {
        return head; // 终止条件
    }
    ListNode newHead = reverseList(head.next);
    head.next.next = head; // 反转指向
    head.next = null;      // 断开原指针
    return newHead;
}

时间复杂度O(n)，空间复杂度O(n)（递归栈开销）

关键对比

方法	优点	缺点	适用场景
迭代法	空间效率高(O(1))	逻辑稍复杂	常规需求
递归法	代码简洁	栈溢出风险(长链表)	面试/学习

两种方法均不改变原链表节点值，仅修改指针方向

Java实现链表头插法和尾插法

一、头插法（逆序插入）

‌核心逻辑‌：新节点始终插入链表头部，最终链表顺序与插入顺序相反
‌图解‌：

插入顺序：1→2→3  
头插过程：  
步骤1：插入1 → [1]  
步骤2：插入2 → [2]→[1]  
步骤3：插入3 → [3]→[2]→[1]  

class ListNode {
    int val;
    ListNode next;
    ListNode(int val) { this.val = val; }
}

public class LinkedList {
    private ListNode head;
    
    // 头插法
    public void addAtHead(int val) {
        ListNode newNode = new ListNode(val);
        newNode.next = head;  // 新节点指向原头节点
        head = newNode;       // 更新头节点为新节点
    }
}

头插法每次操作时间复杂度为O(1)，适合需要逆序存储的场景

二、尾插法（顺序插入）

‌核心逻辑‌：新节点插入链表尾部，需维护尾指针，链表顺序与插入顺序一致
‌图解‌：

插入顺序：1→2→3  
尾插过程：  
步骤1：插入1 → [1]  
步骤2：插入2 → [1]→[2]  
步骤3：插入3 → [1]→[2]→[3]  

public class LinkedList {
    private ListNode head;
    private ListNode tail;  // 新增尾指针
    
    // 尾插法
    public void addAtTail(int val) {
        ListNode newNode = new ListNode(val);
        if (head == null) {
            head = newNode;
            tail = newNode;
        } else {
            tail.next = newNode;  // 原尾节点指向新节点
            tail = newNode;       // 更新尾节点
        }
    }
}

尾插法需遍历或维护尾指针，时间复杂度为O(1)（有尾指针时）

三、完整对比

特性	头插法	尾插法
‌插入顺序‌	逆序（后进先出）	顺序（先进先出）
‌时间复杂度‌	O(1)	O(1)（有尾指针时）
‌适用场景‌	栈实现、链表反转	队列实现、顺序存储

如需可视化调试，可打印链表：

public void printList() {
    ListNode curr = head;
    while (curr != null) {
        System.out.print(curr.val + " ");
        curr = curr.next;
    }
}