Reverse Linked List

https://leetcode.com/problems/reverse-linked-list/

Reverse a singly linked list.

解题思路：

类似于插入排序，始终将当前节点插入到最前方。

/**

 * Definition for singly-linked list.

 * public class ListNode {

 *     int val;

 *     ListNode next;

 *     ListNode(int x) { val = x; }

 * }

 */

public class Solution {

    public ListNode reverseList(ListNode head) {

        if(head == null || head.next == null) {

            return head;

        }

        ListNode dummy = new ListNode(0);

        dummy.next = head;

        ListNode first = head;

        ListNode last = head;

        while(last.next != null) {

            ListNode next = last.next.next;

            dummy.next = last.next;

            dummy.next.next = first;

            last.next = next;

            first = dummy.next;

        }

        return dummy.next;

    }

}

但是这样很复杂有没有感觉到？straight forward的方法是，维护两个指针，不断向后面一个的next指向前面的就完成倒置了。

/**

 * Definition for singly-linked list.

 * public class ListNode {

 *     int val;

 *     ListNode next;

 *     ListNode(int x) { val = x; }

 * }

 */

public class Solution {

    public ListNode reverseList(ListNode head) {

        if(head == null || head.next == null) {

            return head;

        }

        ListNode pre = head;

        ListNode cur = head.next;

        head.next = null;

        while(cur != null) {

            ListNode next = cur.next;

            cur.next = pre;

            pre = cur;

            cur = next;

        }

        return pre;

    }

}

这道新题其实是很多题目的子问题，比如 Reverse Nodes in k-Group，Reverse Linked List II。

这道题很简单，下面写写递归的方法。首先是，插入法的递归代码。

/**

 * Definition for singly-linked list.

 * public class ListNode {

 *     int val;

 *     ListNode next;

 *     ListNode(int x) { val = x; }

 * }

 */

public class Solution {

    public ListNode reverseList(ListNode head) {

        if(head == null || head.next == null) {

            return head;

        }

        ListNode dummy = new ListNode(0);

        dummy.next = head;

        return reverse(dummy, dummy.next);

    }

    

    public ListNode reverse(ListNode dummy, ListNode pre) {

        if(pre.next == null) {

            return dummy.next;

        }

        ListNode next = pre.next.next;

        pre.next.next = dummy.next;

        dummy.next = pre.next;

        pre.next = next;

        return reverse(dummy, pre);

    }

}

上面的解法是一个尾递归，其实就是迭代的硬套。好吧，尾递归因为本层递归结束后，可以完全弹出递归栈，所以不需要额外空间，这是它好的地方。但是，在这里，却是有点硬套了。

下面是第二种迭代方法的一个递归方法，思路很简单，却不容易想到。

不断递归获取链表的后一个节点，直到尾节点。然后回溯，将后一个节点指向前一个，前一个指向空节点。

最后返回最后一个节点。

/**

 * Definition for singly-linked list.

 * public class ListNode {

 *     int val;

 *     ListNode next;

 *     ListNode(int x) { val = x; }

 * }

 */

public class Solution {

    public ListNode reverseList(ListNode head) {

        if(head == null || head.next == null) {

            return head;

        }

        ListNode next = head.next;

        ListNode end = reverseList(next);

        next.next = head;

        head.next = null;

        return end;

    }

}