直通BAT面试算法精讲--排序（1）

注：
所有的代码都是用python实现的，都是自己写的，可能有些地方不太完善

冒泡排序问题

时间复杂度：O(n^2)
空间复杂度：O(1)
思想：依次访问元素，逆序就置换。一趟排序后最大（小）的被置换到最后

def bubble_sort(arr,n):
    if not arr:
        return None
    for i in range(n):
        for j in range(n-i-1):
            if arr[j] > arr[j+1]:
                arr[j],arr[j+1] = arr[j+1],arr[j]
    return arr

选择排序

时间复杂度：O(n^2)
空间复杂度：O(1)
思想：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

def select_sort(arr,n):
    for i in range(n):
        min = i
        for j in range(i+1,n):
            if arr[j]<arr[min]:
                min = j
        arr[i],arr[min] = arr[min],arr[i]
    return arr

插入排序

时间复杂度：O(n^2)
空间复杂度：O(1)

#直接插入排序
def insert_sort(arr,n):
    for i in range(n):
        x = arr[i]
        j = i-1
        while j>=0:
            if x<arr[j]:
                arr[j+1] = arr[j]
            else:
                break
            j -= 1
        arr[j+1] = x            
    return arr

#折半插入排序
def half_insert_sort(arr,n):
    for i in range(1,n):
        if arr[i-1]>arr[i]:
            temp = arr[i]
            low = 0 
            high = i-1
            while low<=high:
                mid = (low+high) // 2
                if arr[mid] < temp:
                    low += 1
                else:
                    high -= 1
            j = i
            while j>=low:
                arr[j] = arr[j-1]
                j -= 1
            arr[low] = temp 
    return arr

归并排序

时间复杂度：O(nlogn)
空间复杂度：O(n)

def merge_sort(arr):
    if not arr or len(arr)<2:
        return arr
    mid = len(arr)//2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left,right)

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

快速排序

时间复杂度：O(nlogn)
空间复杂度：O(nlongn)~O(n)

def quicksort(arr):
    if not arr:
        return 
    quick_sort(arr,0,len(arr)-1)
    return arr
def quick_sort(arr,left,right):
    if left<right:
        i = partition(arr,left,right)
        quick_sort(arr,left,i-1)
        quick_sort(arr,i+1,right)
def partition(array, left, right):
    x = array[right]
    i = left - 1
    for j in range(left, right):
        if array[j] <= x:
            i += 1
            array[i], array[j] = array[j], array[i]
    array[i + 1], array[right] = array[right], array[i+1]
    return i + 1

堆排序

时间复杂度：O(nlogn)
空间复杂度：O(nlogn)

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

def fixDown(arr,i,n):
    while (2*i+1)<n:
        j = 2*i+1
        if j+1<n and arr[j]<arr[j+1]:
            j += 1
        if arr[j] <= arr[i]:
            break
        else:
            arr[i],arr[j] = arr[j],arr[i]
            i = j

希尔排序

时间复杂度：O(nlogn)
空间复杂度：O(1)

def shell_sort(arr):
    step = len(arr)
    while step>1:
        step = step//2
        for i in range(len(arr)):
            j = i
            while j>0:
                if arr[j-step]>arr[j]:
                    arr[j-step],arr[j] = arr[j],arr[j-step]
                else:
                    break
                j -= step
    return arr