面试之排序算法python实现

冒泡排序算法：复杂度o(n^2)

def swap(arr, i, j):
    temp = arr[i]
    arr[i] = arr[j]
    arr[j] = temp
    return arr
    
def maopao(arr):
    n=len(arr)
    for i in range(n):
        for j in range(0,n-i-1):
            if arr[j+1]<arr[j]:
                swap(arr,j+1,j)
    return arr

选择排序：复杂度o(n^2)
思想：每次从数组里选一个最小的元素直接放到有序区的前面，直到整个数组变有序区

def select_sort(arr):
    n = len(arr)
    for i in range(n):
        m = i
        for j in range(i + 1, n):
            if arr[m] > arr[j]:
                m = j
        arr = swap(arr, i, m)
    return arr

插入排序：复杂度o(n^2)
每次将一个待排序的数据，跟前面已经有序的序列的数字比较，找到自己合适的位置

def insert_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(i):
            if arr[j] > arr[i]:
                arr = swap(arr, j, i)
    return arr

希尔排序：复杂度o(n^1.3)
思想：先将整个待排元素序列分割成若干个子序列后进行直接插入排序

def shell_sort(arr):
    n=len(arr)
    step=n//2
    while step!=0:
        for i in range(step):
            j=i
            while j<n:
                if j+step<n and arr[j+step]<arr[j]:
                    swap(arr,j+step,j)
                j+=step
        step=step//2
    return arr

快排：复杂度o(nlogn)
思想：二分治法，选取一个基准数，小于基准数放在左边，大于放在右边

def quick_sort(arr, start, end):
    if start >= end:
        return arr
    left = start
    right = end
    mid = arr[end]
    while left < right:
        while arr[left] < mid and left < right:
            left += 1
        while arr[right] >= mid and left < right:
            right -= 1
        arr = swap(arr, left, right)
    if arr[left] >= arr[end]:
        arr = swap(arr, left, end)
    else:
        left += 1
    arr = quick_sort(arr, start, left - 1)
    arr = quick_sort(arr, left + 1, end)
    return arr

堆排序：复杂度o(nlogn)

def heapify(arr,n,i):
    l=2*i+1#左
    r=2*i+2#右
    lar=i
    if l<n and arr[l]>arr[lar]:
        lar=l
    if r<n and arr[r]>arr[lar]:
        lar=r
    if lar!=i:
        arr[lar],arr[i]=arr[i],arr[lar]
        heapify(arr, n, lar)
    return arr

def heapify_sort(arr):
    n=len(arr)
    for i in range((n-1)//2,-1,-1):
        arr=heapify(arr,n,i)
    for i in range(n-1,0,-1):
        arr[i], arr[0] = arr[0], arr[i]
        arr=heapify(arr,i,0)
    return arr

归并排序

def merge(left,right):
    temp=[]
    i=0
    j=0
    while i<len(left) and j<len(right):
        if left[i]<right[j]:
            temp.append(left[i])
            i+=1
        else:
            temp.append(right[j])
            j += 1
    while i<len(left):
        temp.append(left[i])
        i += 1
    while j<len(right):
        temp.append(right[j])
        j += 1
    return temp

def merge_sort(arr):
    n=len(arr)
    if n<=1:
        return arr
    middle=n//2
    left=merge_sort(arr[:middle])
    right=merge_sort(arr[middle:])
    return merge(left,right)