python 算法 day7 排序

冒泡排序

冒泡排序需要对一个列表进行多次重复性遍历，他要比较相邻的两项，并且交换排错的项，每对列表进行一次遍历，就有一个最大的项排在正确的位置

def bubble(num_list):
    index = len(num_list)
    for j in range(index-1,0,-1):#最大值拿到后列表排序长度减一
        for i in range(j):# 每次循环拿出一个最大值
            if num_list[i]>num_list[i+1]:
                temp = num_list[i]
                num_list[i] = num_list[i+1]
                num_list[i+1] = temp

    return num_list
print(bubble([2,3,21,3,1]))

此时的冒泡排序需要在最终位置找到之前不断交换数据项，因此也被认为是最低效的排序方法，

改良版的冒泡排序，循环过程中发现没有交换，我们就可以断定列表已经排好，在发现列表已经排好时立马结束循环，通常也被称为“短路冒泡排序”

def shortbubble(alist):
    exchange = True #判断是否排好
    poi = len(alist)
    while exchange and poi>0:
        exchange = False
        for i in range(poi-1):
            if alist[i]>alist[i+1]:
                exchange = True
                temp = alist[i]
                alist[i] = alist[i+1]
                alist[i+1] = temp
        poi = poi-1
    return alist

选择排序

选择排序提高了冒泡排序的性能，它每遍历一次列表只交换一次数据，即进行遍历时找到最大的项，第二次找次大的项放到正确位置

def selectSort(alist):
    last_index = len(alist)
    for i in range(last_index-1,0,-1):
        positionmax = 0
        for j in range(0,i):
            max = alist[positionmax]
            if max<alist[j]:
                max = alist[j]
                positionmax = j #需要位置参数记录最大值所在位置
        alist[positionmax] = alist[i]
        alist[i] = max
    return alist

插入排序

插入排序算法复杂度仍然是O(n²)  他总是保持一个位置靠前的已排好的子表，然后新来的数据项插入字表中

def insertSort(alist):
    for index in range(1,len(alist)):
        currentvalue = alist[index]
        position = index
        while currentvalue<alist[index-1] and position>0:
            alist[position] = alist[position-1]
            position = position-1
            alist[position] = currentvalue
    return alist

 希尔排序

 希尔排序以插入排序为基础，将原来要排序的列表划分成一些子列表，再对每个子列表进行插入排序，从而实现对算法的改进 ，主要是确定划分间隔

 

def shellSort(alist):
    sublistcount = len(alist)//4
    print(sublistcount)
    while sublistcount>0:
        for startposition in range(sublistcount):
            gapinsertSort(alist,startposition,sublistcount)
        sublistcount = sublistcount -1  #最后gap成1 变成插入排序
    return alist
def gapinsertSort(alist,start,gap):
    for i in range(start+gap,len(alist),gap):
        currentvalue = alist[i]
        position = i
        while position>=gap and alist[position-gap]>currentvalue:
            alist[position] = alist[position-gap]
            position=position-gap
            alist[position] =currentvalue
    return alist

 希尔排序的算法时间复杂度 大致介于O(n)和O(n 2 )之间