JAVA反转链表

/**
 * 1->2->3  =>  1<-2<-3
 */
public class ReverseList {

    // 循环实现：遍历链表，直接修改next指向，重点是修改前要暂存next值，否则切换指向后无法继续遍历了
    public static Node reverse1(Node head) {
        Node pre = null;
        Node current = head;
        while (current != null) { // 存在当前节点，一直循环往后找
            Node next = current.next;  // 暂存下一节点
            current.next = pre;  // 当前节点指向修改：指向后节点改成指向前节点

            //为下次循环做准备
            pre = current;  // 下次前节点就是当前节点
            current = next; //下次当前节点就是下一节点
        }
        // 退出的时候current==null,pre不为空是尾部节点，现在变成了头节点
        return pre;
    }

    // 递归实现: 递归进入直到尾部节点(next==null)开始反转,需要子结果 → 先递归后处理
    public static Node reverse2(Node head) {
        if (head == null || head.next == null) {
            // 退出条件：下一节点为空，就是尾部节点，反转后就是头节点
            return head;
        }
        // 下一节点不为空（递归调用,假设这个能帮我把后续链表反转好）
        Node newHead = reverse2(head.next);

        // 递归退出的时候，考虑当前反转即可
        head.next.next = head; // 下一节点指向自己（反转）
        head.next = null; // 原指针置空

        // 返回头节点
        return newHead;
    }


    public static void main(String[] args) {
        Node list = build();
        print(list);

//        Node revList = reverse1(list);
        Node revList = reverse2(list);
        print(revList);
    }

    private static Node build() {
        Node node1 = new Node();
        node1.val = 1;
        Node node2 = new Node();
        node2.val = 2;
        Node node3 = new Node();
        node3.val = 3;
        node1.next = node2;
        node2.next = node3;
        return node1;
    }

    public static void print(Node node) {
        StringBuilder builder = new StringBuilder();
        while (node != null) {
            builder.append(node.val);
            if (node.next != null) {
                builder.append("->");
            }
            node = node.next;
        }
        System.out.println(builder);
    }


    static class Node {
        Object val;
        Node next;

    }
}