python第19天排序算法

一、冒泡排序

def bubble_sort(alist):
    n=len(alist)
    for j in range(n-1):
        count=0#如果已经是有序则退出循环
        #控制游标总共要走多少次
        for i in range(0,n-1-j):
            #游标一次从头走到尾,
            if alist[i]>alist[i+1]:
                alist[i],alist[i+1]=alist[i+1],alist[i]
                count+=1
        if 0==count:
            return
if __name__=='__main__':
    li=[54,32,44,55,3,4]
    print(li)
    bubble_sort(li)
    print(li)
最优时间复杂度o(n)
最坏时间复杂度o(n^2

二、选择排序

 先找最小的数
    对剩余的再进行遍历，找出最小的
def select_sort(alist):
    n=len(alist)
    for j in range(n-1):
        min_index = j
        for i in range(j+1,n):
            if alist[min_index]>alist[i]:
                min_index=i
        alist[j],alist[min_index]=alist[min_index],alist[j]
if __name__=='__main__':
    li=[54,32,32,44,55,3,4]
    print(li)
    select_sort(li)
    print(li)
时间复杂度：o(n^2)

三、插入排序

def insert_sort(alist):
    n=len(alist)
    for j in range(1,n):
        i=j
        while i>0:
            if alist[i]<alist[i-1]:
                alist[i],alist[i-1]=alist[i-1],alist[i]
                i-=1
            else:
                break
if __name__=='__main__':
    li=[54,32,32,44,55,3,4]
    print(li)
    insert_sort(li)
    print(li)
    最优时间复杂度o(n)
    最坏时间复杂度o(n^2)

四、希尔排序

  插入排序的改进，，按照一定的间隔，分为若干无序序列，然后对每个序列按照插入排序进行
def shell_sort(alist):
    n=len(alist)
    gap=n // 2
    while gap>0:#缩短gap步长
        for j in range(gap,n):
            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//=2
if __name__=='__main__':
    li=[54,32,32,44,55,3,4]
    print(li)
    shell_sort(li)
    print(li)
    最坏时间复杂度o(2)

五、快速排序

def quick_sort(alist,first,last):
    if 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]
        while low<high and alist[low]<mid_value:
            low+=1
        alist[high]=alist[low]
    #从循环退出时low==high
    alist[low]=mid_value
    #递归嵌套
    quick_sort(alist,first,low-1)#左边快速排序，但必须作用于整个列表，不能作用于列表的切片
    quick_sort(alist, low+1, last)#右边快速排序
if __name__=='__main__':
    li=[54,32,32,44,55,3,4]
    print(li)
    quick_sort(li,0,len(li)-1)
    print(li)
    最优时间复杂度o(nlogn)
    最坏时间复杂度o(n^2)

六、归并算法

def merge_sort(alist):
    n=len(alist)
    if n<=1:
        return alist
    mid=n//2
    #left采用归并排序后，形成有序的新的列表
    left_li=merge_sort(alist[:mid])
    #right采用归并排序后形成的有序的新的列表
    right_li=merge_sort(alist[mid:])
    #将两个有序的子序列合并为有个新的整体
    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,32,32,44,55,3,4]
    print(li)
    sorted_li=merge_sort(li)
    print(li)
    print(sorted_li)

七、二分查找

  条件：有序的序列
1、递归算法
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)
        else:
            return binary_search(alist[mid+1:],item)
    return False
2、非递归版本二分查找
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=[2,4,5,67,88,98]
    print(binary_search_2(li,5))
    print(binary_search_2(li,100))
    最坏时间复杂度o(logn)
    最优时间复杂度o(1)