Leetcode: Sort List 理解分析

题目大意：给定一个链表，要求在O(nlogn)的时间复杂度且常量空间对其进行排序。

理解：1）对链表的排序第一反应是冒泡排序，题目很明显要求用更高效的排序方法，看到O(nlogn)就想到快速排序和归并排序，但是快速排序交换节点的次数太多，可能会超时，所以本人采用归并排序，对链表使用归并排序可以不另开空间，只需要常量空间。

2）递归地将链表分段，再调用merge进行合并。

实现：

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    
    public ListNode merge(ListNode s1, ListNode s2) {
        ListNode p = s1, q = s2, s = null;
        ListNode res = new ListNode(0);
        s = res;
        while(p != null && q != null) {
            if(p.val <= q.val) {
                s.next = p;
                p = p.next;
            }
            else {
                s.next = q;
                q = q.next;
            }
            s = s.next;
        }
        while(p != null) {
            s.next = p;
            s = s.next;
            p = p.next;
        }
        while(q != null) {
            s.next = q;
            s = s.next;
            q = q.next;
        }
        return res.next;
    }
    
    public ListNode mergeSort(ListNode head) {
        if(head == null || head.next == null) return head; // 只剩下一个节点
        ListNode pre = null, p = head, q = head;
        while(q != null && q.next != null) { // 用fast-slow法找到链表中间位置
            pre = p;
            p = p.next;
            q = q.next;
            if(q.next != null) q = q.next;
        }
        pre.next = null; // 从中间位置分成两段，p指针指向右边部分的首节点
        ListNode left = mergeSort(head); // 递归分段左边部分
        ListNode right = mergeSort(p); // 递归分段右边部分
        return merge(left, right);
    }
    
    public ListNode sortList(ListNode head) {
        if(head == null || head.next == null) return head;
        return mergeSort(head);
    }
}