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);
}
}