LeetCode 4 Sort List

Sort a linked list in O(nlogn) time using constant space complexity.

分析：

快速排序要求交换元素，对链表不适用，则考虑用归并排序。

技巧及注意：

1，快慢指针法找链表中间点；

2，递归的技巧，不要试图演绎递归的流程，只要能列出 a， 所有子问题，b，递归终止条件，c，当前解与子问题解的关系， 递归就是正确的。

3，如果发现递归有重复子问题，则考虑使用表记录中间结果以降低复杂度，即动态规划。

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    //利用归并排序
    public ListNode sortList(ListNode head) {
        if(head == null || head.next == null)
            return head;
        //快慢指针法找到链表的中间点
        ListNode slow = head;
        ListNode fast = head.next.next;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        //分别对前半部分和后半部分链表进行归并排序
        ListNode l2 = sortList(slow.next);
        slow.next = null;
        ListNode l1 = sortList(head);
        //合并两部分已排序链表
        return merge(l1, l2);
    }
    private ListNode merge(ListNode l1, ListNode l2){
        //个人喜欢建立一个伪头结点，可以避免很多判断
        ListNode newHead = new ListNode(0);
        ListNode tail = newHead;
        ListNode p1 = l1;
        ListNode p2 = l2;
        while(p1 != null && p2 != null){
            if(p1.val <= p2.val){
                tail.next = p1;
                p1 = p1.next;
            }else{
                tail.next = p2;
                p2 = p2.next;
            }
            tail = tail.next;
        }
        //处理没有走到尾部的节点
        if(p1 == null){
            tail.next = p2;
        }else if(p2 == null){
            tail.next = p1;
        }
        return newHead.next;
    }
}