【算法题】链表反转——迭代，递归

题目

将单链表的链接顺序反转过来

例如：
输入：
1 => 2 => 3 => 4 => 5
输出：
5 => 4 => 3 => 2 => 1

一、迭代

package day01;
public class ReverseList {
    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,next;
        ListNode curr = head;
        while (curr != null){
            //处理后续结点，将此结点的后续结点保存到next，然后断开与后续结点的连接
            //在指向前结点 因此代码为curr.next = prev;
            next = curr.next;
            curr.next = prev;
            
            //处理值的变动，将此结点的值保存至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 prev = iterate(node1);
        System.out.println(prev);
    }
}

分析：

采用双指针的思想，用两个临时变量来保存当前结点的值和next指向的值。

① 第一步将此结点的后续结点保存到next，然后断开与后续结点的连接 代码：next = curr.next
② 再指向前结点 因此代码为curr.next = prev
③ 将此结点的值保存至prev，然后将下一个结点的值赋值给此结点
④移动指针 curr = next

二、递归

//递归
    public static ListNode recursion(ListNode head){
        //结束递归条件，一是头节点是空，二是遍历到链表尾部 head.next = null
        if (head == null || head.next == null){
            return head;
        }
        //递归我们从最后一个元素开始（递归的底层机制），
        ListNode new_head = recursion(head.next);
        //此结点的next就代表下一个结点称为2结点，2结点的next指向此结点本身就完成了一次反转
        head.next.next = head;
        //然后把此结点与下结点的线断开，不然会形成环形链表
        head.next = null;
        return new_head;
    }

思路分析：
①用递归递归到最后一个结点
②对于单个结点来说，要反转需要用此结点的next找到下个结点，然后将下个结点的next指向此结点
③第二部完成之后，此结点的next仍然指向后一个结点，这样就会形成环形链表，这不是我们想要看到的，因此需要把此结点的next置为null