Sort List

来源：https://leetcode.com/problems/sort-list

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

 

归并排序（Merge Sort，台湾译作：合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

归并操作(Merge)，也叫归并算法，指的是将两个已经排序的序列合并成一个序列的操作。归并排序算法依赖归并操作。归并排序有多路归并排序、两路归并排序 , 可用于内排序，也可以用于外排序。这里仅对内排序的两路归并方法进行讨论。

算法思路：

1. 把 n 个记录看成 n 个长度为 l 的有序子表
2. 进行两两归并使记录关键字有序，得到 n/2 个长度为 2 的有序子表
3. 重复第 2 步直到所有记录归并成一个长度为 n 的有序表为止。

-- http://bubkoo.com/2014/01/15/sort-algorithm/merge-sort/

 

归并排序的复杂度：

时间复杂度：平均、最好、最坏都是O(nlog₂n)

空间复杂度：辅助存储O(n)

稳定性：稳定

 

方法：

采用归并排序的思想。使用快慢指针找到中间节点，递归地将链表分为左右两部分，当每部分分解到只剩一个节点时，在进行合并及排序。

Java

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeSort(ListNode head1, ListNode head2) {
        ListNode preHead = new ListNode(0);
        ListNode curNode = preHead;
        while(head1 != null && head2 != null) {
            if(head1.val <= head2.val) {
                curNode.next = head1;
                head1 = head1.next;
            } else {
                curNode.next = head2;
                head2 = head2.next;
            }
            curNode = curNode.next;
        }
        curNode.next = head1 != null ? head1 : head2;
        return preHead.next;
    }
    public ListNode sortList(ListNode head) { // 找到中间节点做划分
        if(head == null || head.next == null) {
            return head;
        }
        ListNode low = head, fast = head, preLow = null;
        while(fast != null && fast.next != null) {
            preLow = low;
            low = low.next;
            fast = fast.next.next;
        }
        preLow.next = null;
        ListNode head1 = sortList(head);
        ListNode head2 = sortList(low);
        return mergeSort(head1, head2);
    }
}// 8 ms

Python

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    # 合并及排序
    def merge(self, l1, l2):
        new_head = ListNode(0)
        p = new_head
        cur1, cur2 = l1, l2
        while cur1 and cur2:
            if cur1.val <= cur2.val:
                p.next = cur1
                cur1 = cur1.next
            else:
                p.next = cur2
                cur2 = cur2.next
            p = p.next
        if cur1:
            p.next = cur1
        elif cur2:
            p.next = cur2
        return new_head.next
    
    # 找到中间结点
    def sortList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if head == None or head.next == None:
            return head
        pre, low, fast = head, head, head
        while fast and fast.next:
            pre = low
            low = low.next
            fast = fast.next.next
        pre.next = None
        l1 = self.sortList(head)
        l2 = self.sortList(low)
        return self.merge(l1, l2)