leetcode 刷题-题目3： NlgN时间对单链表进行排序

这题目很基础，回顾排序算法NlgN时间的算法就是归并，快排，堆排，更快的都不是常数空间复杂度的

这里因为是链表，堆排不适合，只剩下快排和归并了，先试验了下快排，

def sortList(self,head):
        if head ==None:
            return head
        left = head.next
        pivot = head
        #pivot.next = None


        less = None
        big = None
        while left !=None:
            if left.val > pivot.val:
                tmp ,left= left,left.next
                tmp.next,big=big,tmp
            else:
                tmp,left = left,left.next
                tmp.next,less = less,tmp




        if less != None and less.next != None:
            less = self.sortList(less)


        if big!= None and  big.next!=None:
            big = self.sortList(big)


        if less == None:
            pivot.next = big
            return pivot
        else:
            tmp=less
            while tmp.next != None:
                tmp = tmp.next
            tmp.next = pivot
            pivot.next = big
            return less

结果：超出TL了，我们知道快排在对输入基本有序的输入进行排序时时间复杂度会降到n^2，当然可以通过随机选择pivot

来解决，这里偷懒，决定先试试归并排序：

def sortList2(self,head):
        if head == None or head.next == None:
            return head
        i=1;
        tmp = head
        while tmp.next != None:
            tmp=tmp.next
            i+=1
        half_i = 1
        tmp = head
        while half_i < i/2:
            tmp = tmp.next
            half_i +=1
            
        sec = tmp.next
        tmp.next = None


        l = self.sortList2(head)
        r = self.sortList2(sec)
        ret = None
        if l==None :
            return r
        if r == None:
            return l


        if l.val < r.val:
            ret = l
            l = l.next
        else:
            ret = r
            r = r.next


        tmp = ret
        while l!=None and r!=None:
            if l.val < r.val:
                tmp.next =  l
                l = l.next
                tmp = tmp.next
            else:
                tmp.next = r
                r = r.next
                tmp = tmp.next


        if l!=None:
            tmp.next = l
        if r!=None:
            tmp.next = r


        return ret

                

结果直接ac了，看来虽然快排虽然比较酷，还是归并靠谱~

使用随机化的pivot选择的快排优化以后有时间再试试。