Chapter 6 希尔排序、快速排序、归并排序、二分查找

希尔排序

希尔排序是插入排序的一种，也称缩小增量排序。

希尔排序时间复杂度

最优时间复杂度:根据步长序列的步长的不同而不同
最坏时间复杂度：O(n²)
稳定性：不稳定

希尔排序算法的实现

#coding = utf-8

def shell_sort(alist):
    '''希尔排序'''
    #n=9
    n=len(alist)
    #gap=4
    gap = n//2
    #gap变化到0之前，插入算法执行的次数
    while gap>=1:
        #插入算法，与普通的插入算法的区别就是步长gap
        for j in range(gap,n):
            #j=[gap,gap+1,gap+2,gap+4,……,n-1]
            i=j
            while i>0:
                if alist[i]<alist[i-gap]:
                    alist[i],alist[i-gap]=alist[i-gap],alist[i]
                    i-=gap
                else:
                    break
        #缩短gap步长
        gap //=2
if __name__=='__main__':
    li=[54,26,93,17,77,31,44,55,20]
    print(li)
    shell_sort(li)
    print(li)

快速排序（难点但必须掌握）

快速排序时间复杂度

最优时间复杂度：O(nlogn)——竖向logn (222*……*2=n 2^次数=n 次数=log2(n)=logn) 横向n
最差时间复杂度：O(n)
稳定：不稳定

快速排序算法的实现

#coding = utf - 8

def quick_sort(alist,first,last):
    '''快速排序'''
    if first >= last:  #只有first<last才会执行，递归停止的条件
        return

    mid_value=alist[first]
    low=first
    high=last

    while low < high:
        #high左移
        while low<high and alist[high]>= mid_value:
            high-=1
        alist[low]=alist[high]

        #low右移
        while low<high and alist[low]<mid_value:
            low+=1
        alist[high]=alist[low]
        #从循环退出时，low==high
    alist[low]=mid_value

    #递归
    #在对mid_value中的左侧进行快速排序
    quick_sort(alist,first,low-1)
    # 在对mid_value中的左侧进行快速排序
    quick_sort(alist,low+1,last)


if __name__=='__main__':
    li=[54,26,93,17,77,31,44,55,20]
    print(li)
    quick_sort(li,0,len(li)-1)
    print(li)

归并排序

归并排序的时间复杂度

最优时间复杂度：O(nlogn)
最坏时间复杂度：O(nlogn)(时间少，但是产生新的空间)
稳定性：稳定

归并排序算法的实现

#coding=utf-8

def merge_sort(alist):
    '''归并排序'''
    n=len(alist)
    mid=n//2
    if n <=1:
        return alist
    #left_li 代表的是采用归并排序后形成的有序的新的列表
    left_li=merge_sort(alist[:mid])

    #right_li 代表的是采用归并排序后形成的有序的新的列表
    right_li=merge_sort(alist[mid:])
#以上是将子序列进行完全拆分

    #将两个有序的子序列合并为一个新的整体
    #merge(left_li,right_li)

    left_pointer,right_pointer=0,0  #指的是左边、右边的指针
    result=[]
    while left_pointer<len(left_li) and right_pointer<len(right_li):
        if left_li[left_pointer]<=right_li[right_pointer]:
            result.append(left_li[left_pointer])
            left_pointer+=1
        else:
            result.append(right_li[right_pointer])
            right_pointer+=1
            
#循环退出后，总会落下一个元素，下面两行就是为了加上这个数。
    result+=left_li[left_pointer:]  
    result+=right_li[right_pointer:]
    return result

if __name__=='__main__':
    li=[54,26,93,17,77,31,44,55,20]
    print(li)
    sorted_li=merge_sort(li)  #有返回值
    print(sorted_li)

归并排序算法——代码执行流程

#1 left_li=merge_sort [54,26,93,17]
    #2 left_li=merge_sort [54,26]
       #3 left_li = [54]
       #4 right_li = [26]
    #result=[26,54]
#5 right_li=merge_sort [93,17]
    #6 right_li=[93]
    #7 right_li=[17]
    #8 result=[17,93]
#9 result=[17,26,54,93]

#10 right_li=merge_sort [77,31,44,55]  和以上的顺序一致
#…………………………………………………………………………………………………………………………………………………………………………………
#result=[31,44,55,77]

#result=[17, 26, 31, 44, 54, 55, 77, 93]

常见排序算法效率比较

二分法查找

二分查找的算法实现

二分查找又称折半查找。
优点：比较次数小，查找速度快，平均性能好。
缺点：要求待查的表为有序表，且插入删除困难。

#coding=utf-8

def binary_search(alist,item):
    '''二分查找,递归版本'''
    n=len(alist)
    if n>0:
        mid = n // 2
        if alist[mid]==item:
            return True
        elif item<alist[mid]:
            return binary_search(alist[:mid],item)  #已经不包含mid
        else:
            return binary_search(alist[mid+1:],item)   #已经不包含mid
    return False  #代表没有找到

def binary_search_2(alist,item):
    '''二分查找，非递归算法'''
    n=len(alist)
    first=0
    last=n-1
    while first<=last:
        mid=(first+last)//2
        if alist[mid]==item:
            return True
        elif item<alist[mid]:
            last=mid-1
        else:
            first=mid+1
    return False

if __name__=='__main__':
    li=[17, 26, 31, 44, 54, 55, 77, 93]
    print(binary_search(li,55))
    print(binary_search(li,60))

    print(binary_search_2(li,55))
    print(binary_search_2(li,60))

二分查找的时间复杂度

最优时间复杂度：O(1) #mid即为item
最坏时间复杂度：O(nlogn)