8大排序之Python实现 冒泡排序优化

1.冒泡排序（从大到小）：交换发生在内部循环

稳定的排序

冒泡排序的平均时间复杂度是O(n2),最好的时间复杂度是O(n),最坏的时间复杂度是O(n2)，空间复杂度为O(1)

冒泡排序的优化在于didswap变量 ，通过这个变量的设置，实现冒泡排序的最好时间复杂度是O(n)

#!usr/bin/python

arr=[1,2,3,4,5,6,7,8,67,5,64,43,546,56,76,34,657,34,45,56,23]
def BubbleSort(list):
    for i in range(len(list)-1):
        didswap = False
        for j in range(len(list)-1-i):
            if list[j]<list[j+1]:
                list[j],list[j+1]=list[j+1],list[j]
                didswap =True
        if didswap == False:
            return list
    return list
print (BubbleSort(arr))

2.选择排序（从大到小）：交换发生在外部循环

不稳定的排序

平均算法复杂度O(n2),最好算法复杂度O(n2),最坏的算法复杂度为O(n2),空间复杂度O(1)

#!usr/bin/python
def SelectSort(lists):
        for i in range(len(lists)-1):
                max=i
                for j in range(i+1,len(lists)):
                        if lists[j]>lists[max]:
                                max=j
                lists[max],lists[i]=lists[i],lists[max]
        return lists

lists=[2,3,4,65,7,6,5,5,6,7,8,6,4]
print SelectSort(lists)

3.插入排序（从大到小排序）：

稳定的排序

平均复杂度O(n2),最好的时间复杂度O(n),最坏的算法复杂度O(n2),空间复杂度是O(1)

#!usr/bin/python
def InsertSort(lists):
        for i in range(1,len(lists)):
                key=lists[i]
                j=i-1
                while j>=0 and lists[j]<key:
                        lists[j+1]=lists[j]
                        j=j-1
                lists[j+1]=key
        return lists

arr=[2,3,4,5,6,8,7,5,6,7,6,4,5,6,7,8,7,5]
print InsertSort(arr)

4.归并排序（从大到小）：归并排序的思想就是分而治之

归并排序是稳定

平均O(nlgn) 最好的时间复杂度是O(nlgn),最坏的时间复杂度是O(nlgn),空间复杂度是O（n）

#!usr/bin/python
def Merge(left,right):
        i,j=0,0
        result=[]
        while i<len(left) and j<len(right):
                if left[i]>=right[j]:
                        result.append(left[i])
                        i+=1
                else:
                        result.append(right[j])
                        j+=1
        result+=left[i:]
        result+=right[j:]
        return result

def MergeSort(lists):
        if len(lists)<2:
                return lists
        div = len(lists)/2
        left=MergeSort(lists[0:div])
        right=MergeSort(lists[div:])
        return Merge(left,right)

lists = [2,3,4,5,6,7,6,5,34,23,4,56,6,3,4,6]
print MergeSort(lists)

5.快速排序：（递归调用）

平均时间复杂度O(nlgn),平均时间复杂度O(nlgn),最坏的时间复杂度O(n2)

空间复杂度O(lgn)-Olg(n)

def QuickSort(myList,start,end):
    #判断low是否小于high,如果为false,直接返回
    if start < end:
        i,j = start,end
        #设置基准数
        base = myList[i]
        while i < j:
            #如果列表后边的数,比基准数大或相等,则前移一位直到有比基准数小的数出现
            while (i < j) and (myList[j] >= base):
                j = j - 1
         #如找到,则把第j个元素赋值给第个元素i,此时表中i,j个元素相等
            myList[i] = myList[j]
            #同样的方式比较前半区
            while (i < j) and (myList[i] <= base):
                i = i + 1
            myList[j] = myList[i]
        #做完第一轮比较之后,列表被分成了两个半区,并且i=j,需要将这个数设置回base
        myList[i] = base

        #递归前后半区
        QuickSort(myList, start, i - 1)
        QuickSort(myList, j + 1, end)
    return myList

lists = [49,38,65,97,76,13,27,49]
print(QuickSort(lists,0,len(lists)-1))
print (lists)

7.堆排序（从大到小）：第一步最小堆化；第二步建立最小堆；第三步堆排序

#!user/bin/python
def AjustHeap(lists,i,size):
        min=i
        left=2*i+1
        right=2*i+2
        if i < size/2:
                if right < size and lists[min] > lists[right]:
                        min=right
                if left < size and lists[min]>lists[left]:
                        min=left
                if min!=i:
                        lists[i],lists[min]=lists[min],lists[i]
                        AjustHeap(lists,min,size)
def BuildHeap(lists,size):
        for i in range(0,(size/2))[::-1]:
                AjustHeap(lists,i,size)
def HeapSort(lists):
        size=len(lists)
        BuildHeap(lists,size)
        for i in range(0,size)[::-1]:
                        lists[i],lists[0]=lists[0],lists[i]
                        AjustHeap(lists,0,i)
        return lists
arr=[12,23,4,3,5,6,7,8,76,43,5,6,7,34,3,76]
print HeapSort(arr)

6.希尔排序（从大到小）：（插入排序的一种）

#!user/bin/python
def ShellSort(lists):
        step=len(lists)/2
        while (step>=1):#step终止循环为1
                for i in range(step,len(lists)):#没一次step对应很多个新列表
                        while(i>=step and lists[i] > lists[i-step]):#每个列表进行排序
                                lists[i],lists[i-step]=lists[i-step],lists[i]
                                i=i-step
                step=step/2
        return lists
arr=[12,23,4,3,5,6,7,8,76,43,5,6,7,34,3,76]
print ShellSort(arr)

8.计数排序：