python实现常见数据结构与算法

#折半查找
def bs(array,goal,low,high):
    mid=(low+high)//2
    while low<=high:
        if goal==array[mid]:
            return mid
        elif goal>array[mid]:
            return bs(array,goal,mid+1,high)
        elif goal<array[mid]:
            return bs(array,goal,low,mid-1)
#分块查找
def IdxSearch(index_list,array,goal):
    high=len(index_list)-1
    low=0
    mid=(high+low)//2
    while low<=high:
        if goal>=index_list[mid][0]:
            low=mid+1
            mid=(high+low)//2
        elif goal<index_list[mid][0]:
            high=mid-1
            mid=(high+low)//2
    for i in range(index_list[high+1][1],index_list[high+1][1]+3):
        if array[i]==goal:
            return i
#直接插入
def DirectInsert(array):
    for i in range(1,len(array)):
        k=i
        while k>=1:
            if array[k]<array[k-1]:
                array[k],array[k-1]=array[k-1],array[k]
                k=k-1
            else:
                break
    print(array)
    return array

#希尔排序
def shellSort(array):
    n=len(array)
    d=n//2
    while d>1:
        for i in range(0,n,d):
            if i+d<=n:
                for j in range(i,i+d):
                        k=j
                        while k>=1:
                            if array[k]<array[k-1]:
                                array[k],array[k-1]=array[k-1],array[k]
                                k=k-1
                            else:
                                break

            else:
                for g in range(i,n):
                        k=g
                        while k>=1:
                            if array[k]<array[k-1]:
                                array[k],array[k-1]=array[k-1],array[k]
                                k=k-1
                            else:
                                break
        d=d//2
    return array
#折半插入
def bianaryInsert(array):
    for i in range(1,len(array)):
        high=i
        low=0
        k=i
        while k>=1:
            if array[k]<array[k-1]:
                tmp=array[k]
                while low<=high:
                    mid=(low+high)//2
                    if array[mid]<=array[k]:
                        low=mid+1
                    else:
                        high=mid-1
                while k>high:
                    array[k]=array[k-1]
                    k-=1
                array[high+1]=tmp
            else:
                break
    return array
#冒泡排序
def bubble(array):
    for i in range(0,len(array)):
        exchange=False
        for j in range(len(array)-1,i,-1):
            if array[j]<=array[j-1]:
                array[j],array[j-1]=array[j-1],array[j]
                exchange=True
        if not exchange:
            return array
    return array
#快速排序（不会默写）
def part(array,start,end):
    mid=array[start]
    while start<end:
        while array[end]>=mid and start<end:
            end-=1
        array[start]=array[end]
        while array[start]<=mid and start<end:
            start+=1
        array[end]=array[start]
    array[start]=mid
    return start
def quikSort(array,low,high):
    if high>low:
        mid=part(array,low,high)
        quikSort(array,mid+1,high)
        quikSort(array,low,mid-1)
#简单选择排序
def simpleChoice(array):
    for i in range(0,len(array)):
        small=array[i]
        for j in range(i,len(array)):
            if array[j]<small:
                small=array[j]
                s=j
                array[s],array[i]=array[i],array[s]
    return array
#基数排序
def radioSort(array):
    max_num=len(str(max(array)))
    #基数桶
    for l in range(0,max_num):
        sort=[[]for _ in range(10)]
        for i in array:
            for j in range(0,10):
                if i //pow(10,l)%10==j:
                    sort[j].append(i)
        array.clear()
        for i in sort:
            array+=i
        print(array)

#二路归并(编写)
def merge(left,right):
    l,r=0,0
    all_list=[]
    while l<len(left) and r<len(right):
        if left[l]<=right[r]:
            all_list.append(left[l])
            l+=1
        else:
            all_list.append(right[r])
            r+=1
    all_list+=left[l:]
    all_list+=right[r:]
    return all_list

def binaryMerge(array):
    if len(array)<=1:
        return array
    mid=len(array)//2
    left=binaryMerge(array[:mid])
    right=binaryMerge(array[mid:])
    return merge(left,right)

#堆排序
def adjustHeap(heap,size,root):
    left=2*root+1
    right=left+1
    larger=root
    if left<size and heap[larger]<heap[left]:
        larger=left
    if right<size and heap[larger]<heap[right]:
        larger=right
    if larger !=root:
        heap[larger],heap[root]=heap[root],heap[larger]
        adjustHeap(heap,size,larger)
        print(heap)
def buildHeap(array):
    size=len(array)
    for i in range((size-2)//2,-1,-1):
        adjustHeap(array,size,i)

def heapSort(array):
    buildHeap(array)
    for i in range(len(array)-1,-1,-1):
        array[0],array[i]=array[i],array[0]
        adjustHeap(array,i,0)
    print(array)