排序算法

十大排序方法

1.冒泡排序

算法思想：比较相邻的元素，如果x1>x2，则交换（swap）它们，一直重复。下面的代码时升序冒泡排序

def bubbleSort(arr):
    for i in range(1, len(arr)):
        for j in range(0, len(arr)-i):
            if arr[j] > arr[j+1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr
        
try:
    a=[23,46,0,8,11,18]
    bubbleSort(a)
    print(a)
except:
    print("error!")

2.选择排序

时间复杂度是O(n*n）
算法思想：在末排序序列中找到最小（大）元素，存放到排序序列的起始位置，再从剩余未排序元素中继续寻找最小（大）元素，放在已排序序列的末尾，重复直到排序完成。

def selectsort(a):
    temp=0 #记住最小的位置
    for i in range(0,len(a)-1):
        for j in range(i+1,len(a)-1):
            if(a[i]>=a[j] and a[temp]>=a[j]):
                a[i],a[j]=a[j],a[i]
                temp=j
                

3.插入排序

工作原理是通过构建有序序列，对于未排序数据，在已排序序列中找到合适位置插入。插入排序就是把第一个数算是有序的，后面的无序，每次以有序为界限向后移动，比较移动和现在需要插入的数据。

def insertionsort(arr):
    for i in range (len(arr)):
        j=i-1
        current=arr[i]
        while j>=0 and arr[j]>current:
            arr[j+1]=arr[j]
            j=j-1
        a[j+1]=current
    return arr

优化算法：拆半插入排序（寻找插入点）
可以利用拆半的方法来加速寻找插入点的速度，将插入区域的首元素设置为a[low],末元素设置为a[high],m=(low+high)/2，比较插入数与a[m]的大小确定待插入的区域，直到low<=high不成立，则将此位置之后的所有元素后移一位。时间复杂度o(n*n)

def baninsertionsort(arr):
    for i in range(1,len(arr)):
        low,high=0,i-1
        current=a[i]
        m=int((low+high)/2)
        while low<=high:
            m=int((low+high)/2)
            if(arr[m]<current):
                low=m+1
            else:
                high=m-1
        #print(low,high, i-1)
        for j in range (i-1,high,-1):
            arr[j+1]=arr[j]
        arr[high+1]=current
    return arr

4.希尔排序

逻辑分组对序列进行排序，之后减半再分组排序，直到减少到1后再进行插入排序。
实际上实现就是在插入排序上增加了控制变量gap的循环
希尔排序直观理解

def shellsort(arr):
    import math
    gap=1
    while(gap<len(arr)/3):
        gap=gap*3+1
    while gap>0:
        for i in range(gap,len(arr)):
            temp = arr[i]
            j = i-gap
            while j >=0 and arr[j] > temp:
                arr[j+gap]=arr[j]
                j-=gap
            arr[j+gap] = temp
        gap = math.floor(gap/3)
    return arr

5.归并排序

采用分治法，实现由两种：自上而下的递归；自下而上的迭代
将已经有序的两个子序列合成一个有序序列；或者多个有序子序列则可以通过临近的两个先排序最后归并到两个排序的子序列中，再进行排序。

def mergeSort(arr):
    import math
    if(len(arr)<2):
        return arr
    middle = math.floor(len(arr)/2)
    left, right = arr[0:middle], arr[middle:]
    return merge(mergeSort(left), mergeSort(right))

def merge(left,right):
    result = []
    while left and right:
        if left[0] <= right[0]:
            result.append(left.pop(0))
        else:
            result.append(right.pop(0));
    while left:
        result.append(left.pop(0))
    while right:
        result.append(right.pop(0));
    return result

6.快速排序

参考网址排序原理+Java实现
每一轮挑选基准元素，并把比它大的移到一边，小的元素移动到另一边。
指针交换法：经过三次的将序列排好序

def quickSort(arr, left=None, right=None):
    left = 0 if not isinstance(left,(int, float)) else left
    right = len(arr)-1 if not isinstance(right,(int, float)) else right
    if left < right:
        partitionIndex = partition(arr, left, right)
        quickSort(arr, left, partitionIndex-1)
        quickSort(arr, partitionIndex+1, right)
    return arr

def partition(arr, left, right):
    pivot = left
    index = pivot+1
    i = index
    while  i <= right:
        if arr[i] < arr[pivot]:
            swap(arr, i, index)
            index+=1
        i+=1
    swap(arr,pivot,index-1)
    return index-1

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