直通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(i+1,n):
            if arr[i] > arr[j]:
                arr[i],arr[j] = arr[j],arr[i]
    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(1,n):
        for j in range(i):
            if arr[i] < arr[j]:
                arr.insert(j,arr.pop(i))
                break
    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
    result += left[i:]
    result += right[j:]
    return result

快速排序

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

import random

def quick_sort(arr):
    quickSort(arr,0,len(arr)-1)
    return arr

def quickSort(arr,left,right):
    if left >= right:
        return 
    j = partition(arr,left,right)
    quickSort(arr,left,j-1)
    quickSort(arr,j+1,right)

def partition(arr,left,right):
    rand = random.randint(left,right)
    exchange(arr,rand,right)
    index = left
    for i in range(left,right):
        if arr[i] <= arr[right]:
            exchange(arr,index,i)
            index += 1
    exchange(arr,index,right)
    return index

def exchange(arr,i,j):
    arr[i],arr[j] = arr[j],arr[i]

堆排序

时间复杂度：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(step,len(arr)):
            for j in range(i%step,i,step):
                if arr[j]>arr[i]:
                    arr[i],arr[j] = arr[j],arr[i]
    return arr