Sort List

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

用归并算法，先找到 list 的中点，然后用 divide and conquer

1. 用 slow,fast 找到中点

2. 合并两个 sorted list

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

class Solution:
    # @param head, a ListNode
    # @return a ListNode
    def sortList(self, head):
        return self.mergesort(head)
        
    def mergesort(self,head):
        if head==None or head.next==None:
            return head
        
        slow = fast = head
        while(fast.next!=None and fast.next.next!=None):
            slow = slow.next
            fast = fast.next.next
        sec = slow.next
        slow.next = None
        
        head = self.mergesort(head)
        sec = self.mergesort(sec)
        return self.mergetwo(head,sec)
    
    def mergetwo(self,first,sec):
        dummy = ListNode(100)
        cur = dummy
        cur1,cur2 = first, sec
        
        while True:
            if cur1==None:
                cur.next = cur2
                return dummy.next
            if cur2==None:
                cur.next = cur1
                return dummy.next
            
            if cur1.val < cur2.val:
                cur.next = cur1
                cur = cur.next
                cur1 = cur1.next
            else:
                cur.next = cur2
                cur = cur.next
                cur2 = cur2.next
                

c++

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *sortList(ListNode *head) {
        mergesort(head);      
    }
    
    ListNode *mergesort(ListNode *head){
        if(head==NULL || head->next==NULL){
            return head;
        }
        
        ListNode *slow = head, *fast = head;
        while(fast->next!=NULL && fast->next->next!=NULL){
            slow = slow->next;
            fast = fast->next->next;
        }
        ListNode *sec = slow->next;
        slow->next = NULL;
        head = mergesort(head);
        sec = mergesort(sec);
        return mergetwo(head,sec);
    }
    
    ListNode *mergetwo(ListNode *first, ListNode *sec){
        ListNode *dummy = new ListNode(100);
        ListNode *cur=dummy, *cur1=first, *cur2=sec;
        while(1){
            if(cur1==NULL){
                cur->next = cur2;
                return dummy->next;
            }
            if(cur2==NULL){
                cur->next = cur1;
                return dummy->next;
            }
            if(cur1->val<cur2->val){
                cur->next = cur1;
                cur1 = cur1->next;
            }else{
                cur->next = cur2;
                cur2 = cur2->next;
            }
            cur = cur->next;
        }
    }
    
};