Python数据结构——排序与搜素

Python数据结构——排序与搜素

冒泡排序

冒泡排序具有稳定性
时间复杂度：最好：O（n），最坏：O（n2），平均：O（n2）
每次过程都能把最大的数放在最后，因此内层循环只需到n-j-1

def bubble_sort(alist):
    n=len(alist)
    for j in range(n-1):
        count=0
        for i in range(n-1-j):
            if alist[i]>alist[i+1]:
              alist[i],alist[i+1]=alist[i+1],alist[i]
              count+=1
        if count==0:
            return
if __name__=='__main__':
    li=[54,26,93,17,77,31,44,55,20]
    print(li)
    bubble_sort(li)
    print(li)

选择排序

选择排序不具有稳定性
时间复杂度：最好：O（n2），最坏：O（n2），平均：O（n2）

def select_sort(alist):
    "选择排序"
    n=len(alist)
    for j in range(n-1):#j:0-n-2
        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, 226, 93, 17, 77, 31, 44, 55, 20]
    print(li)
    select_sort(li)
    print(li)

插入排序

插入排序具有稳定性
时间复杂度：最好：O（n），最坏：O（n2）

def insert_sort(alist):
    "选择排序"
    n=len(alist)
    for j in range(1,n):#j:0-n-2
        for i in range(j,0,-1):
            if alist[i]<alist[i-1]:
              alist[i],alist[i-1]=alist[i-1],alist[i]

if __name__=='__main__':
    li = [54, 226, 93, 17, 77, 31, 44, 55, 20]
    print(li)
    insert_sort(li)
    print(li)

希尔排序——shell sort

希尔排序不具有稳定性
时间复杂度：最好：根据步长序列不同而不同，最坏：O（n2）

GAP

def shell_sort(alist):
    "选择排序"
    n=len(alist)
    gap=n//2
    i=1
    #gap变化到0之前，插入算法执行的次数
    while gap>0:
        for j in range(gap,n):#保证一个循环完成当前gap所有子序列
            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, 30]
    print(li)
    shell_sort(li)
    print(li)

快速排序

时间复杂度：最好：O（nlogn），最坏：O（n2）

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]
     alist[high]=mid_value


         #对low左边的列表执行快速排序
     quick_sort(alist,first,low-1)
         # 对low右边的列表执行快速排序
     quick_sort(alist,low+1,last)

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

归并排序

时间复杂度：最好：O（nlogn），最坏：O（nlogn），稳定

    #left_li为采用归并排序后形成的有序的新的列表
    left_li=merge_sort(alist[:mid])
    # right_li为采用归并排序后形成的有序的新的列表
    right_li=merge_sort(alist[mid:])
    #将两个有序子序列合并成新的整体
    #merge(left,right)
    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, 30]
    print(li)
    sorted_li=merge_sort(li)
    print(li)
    print(sorted_li)

重点：快速排序

二分查找：

递归版本：

def binary_search(alist,item):
    '二分查找'
    n=len(alist)
    if n>0:
        mid=n//2
        if alist[mid]==item:
            return mid
        elif item <alist[mid]:
            return(binary_search(alist[:mid], item))
        elif item < alist[mid]:
            return(binary_search(alist[mid+1:], item))
    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=[1,2,3,4,5,6,7,8,9]
    print(binary_search(li,3))
    print(binary_search(li, 55))

二分查找：时间复杂度
时间复杂度：最好：O（1），最坏：O（logn）