1.链表反转

题目：输入节点1，输出反转后的节点。

链表特性：必须根据指针（next）找到下一个元素

方法一：迭代

• 要解决的问题： 5是不知道前面是4，4不知道前面是3。。。所以我们需要增加一个前置标记，prev。这样一来，5就知道前面是4，将4变为5的下个节点，其余同理。

代码：

public class ReverseList {
    @Data
    static class ListNode {
        int val;
        ListNode next;

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

    public static ListNode iterate(ListNode head) {
        //定义前置节点，当前节点，下个节点
        ListNode prev = null, curr, next;
        curr = head;
        while (curr != null) {
            //备份下个节点
            next = curr.next;
            //将当前节点的下个节点，设置为前置节点 ( 即变为 1 next null ， 2 next 1。。)
            curr.next = prev;
            //将前置节点，设置为当前节点
            prev = curr;
            //将当前节点设置为下个节点，开始下个节点迭代
            curr = next;
        }
        return prev;
    }

    public static void main(String[] args) {
        ListNode node5 = new ListNode(5, null);
        ListNode node4 = new ListNode(4, node5);
        ListNode node3 = new ListNode(3, node4);
        ListNode node2 = new ListNode(2, node3);
        ListNode node1 = new ListNode(1, node2);
        ListNode node = iterate(node1);
    }
}

结果：{"val":5,"next":{"val":4,"next":{"val":3,"next":{"val":2,"next":{"val":1}}}}}

方法二：递归

类似树结构，先从根节点找到叶子节点，从叶子节点开始遍历。

错误的方式： 从前往后找

 public static void recursion(ListNode head) {
        //获取下个节点
        ListNode next = head.next;
        //清空当前节点的next
        head.next = null;
        //将下个节点的下个节点，设置为当前节点
        next.next = head;
        //如上，虽然2 next 1 了，但此时也找不到节点3了，所以我们应该先递归找到最后一个节点
        recursion(xx);
    }

正确方式： 先递归找到最后一个节点

public class ReverseList {
    @Data
    static class ListNode {
        int val;
        ListNode next;

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

    public static ListNode recursion(ListNode head) {
        //节点为空 或 下个节点为null，说明遍历到最后一个，直接返回
        if (head == null || head.next == null) {
            return head;
        }
        //递归到 head为4时，开始遍历
        ListNode newHead = recursion(head.next);
        head.next.next = head;
        head.next = null;
        return newHead;
    }

    public static void main(String[] args) {
        ListNode node5 = new ListNode(5, null);
        ListNode node4 = new ListNode(4, node5);
        ListNode node3 = new ListNode(3, node4);
        ListNode node2 = new ListNode(2, node3);
        ListNode node1 = new ListNode(1, node2);
        ListNode node_1 = recursion(node1);
        System.out.println(JSONUtil.toJsonStr(node_1));
    }
}

区别

• 迭代：重复某一过程，每一次处理结果作为下一次处理的初始值（状态的变更）。
• 递归：重复某一过程，将大问题拆成小问题。