Leetcode之Sort List

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

Subscribe to see which companies asked this question

解题报告：就是对一个链表进行归并排序。
主要考察3个知识点，
知识点1：归并排序的整体思想
知识点2：找到一个链表的中间节点的方法
知识点3：合并两个已排好序的链表为一个新的有序链表

归并排序的基本思想是：找到链表的middle节点，然后递归对前半部分和后半部分分别进行归并排序，最后对两个以排好序的链表进行Merge

python代码：

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

class Solution(object):
    def sortList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if head == None or head.next == None:
            return head;
        
        medium = self.getMiddle(head)
        next = medium.next
        medium.next = None
        
        return self.mergeList(self.sortList(head), self.sortList(next))
        
    def getMiddle(self, head):
        slow = head
        fast = head
        
        while fast.next != None and fast.next.next != None:
            slow = slow.next
            fast = fast.next.next
        return slow
        
    def mergeList(self, former, latter):
        dummy_head = ListNode(-1)
        cur = dummy_head
        
        while former != None and latter != None:
            if former.val <= latter.val:
                cur.next = former
                former = former.next
            else:
                cur.next = latter
                latter = latter.next
            cur = cur.next
        
        if former != None:
            cur.next = former
        if latter  != None:
            cur.next = latter
        
        return dummy_head.next
            

Java代码：

1. public class Solution {  
2.      //use the fast and slow pointer to get the middle of a ListNode  
3.      ListNode getMiddleOfList(ListNode head) {  
4.         ListNode slow = head;  
5.         ListNode fast = head;  
6.         while(fast.next!=null&&fast.next.next!=null) {  
7.             slow = slow.next;  
8.             fast = fast.next.next;  
9.         }  
10.         return slow;  
11.     }  
12.       
13.     public ListNode sortList(ListNode head) {  
14.         if(head==null||head.next==null) {  
15.             return head;  
16.         }  
17.         ListNode middle = getMiddleOfList(head);  
18.         ListNode next   = middle.next;  
19.             middle.next = null;  
20.         return mergeList(sortList(head), sortList(next));  
21.     }  
22.       
23.     //merge the two sorted list  
24.     ListNode mergeList(ListNode a, ListNode b) {  
25.         ListNode dummyHead = new ListNode(-1);  
26.         ListNode curr = dummyHead;  
27.         while(a!=null&&b!=null) {  
28.             if(a.val<=b.val) {  
29.                 curr.next=a;a=a.next;  
30.             } else {  
31.                 curr.next=b;b=b.next;  
32.             }  
33.             curr  = curr.next;  
34.         }  
35.         curr.next = a!=null?a:b;  
36.         return dummyHead.next;  
37.     }  
38. }