python关于冒泡，选择，插入，归并，快速排序

一、冒泡排序

1.算法步骤

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

2.关于复杂度

排序算法	平均时间复杂度	最好情况	最坏情况	空间复杂度	排序方式	稳定性
冒泡排序	O(n2)	O(n)	O(n2)	O(1)	In-place	稳定

3.代码展示

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

二、选择排序

1.算法步骤

1. 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
2. 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
3. 重复第二步，直到所有元素均排序完毕。

2.关于复杂度

排序算法	平均时间复杂度	最好情况	最坏情况	空间复杂度	排序方式	稳定性
选择排序	O(n2)	O(n2)	O(n2)	O(1)	In-place	不稳定

3.代码展示

def selectionSort(arr):
    for i in range(len(arr) - 1):
        # 记录最小数的索引
        minIndex = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[minIndex]:
                minIndex = j
        # i 不是最小数时，将 i 和最小数进行交换
        if i != minIndex:
            arr[i], arr[minIndex] = arr[minIndex], arr[i]
    return arr

三、插入排序

1.算法步骤

1. 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
2. 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

2.关于复杂度

排序算法	平均时间复杂度	最好情况	最坏情况	空间复杂度	排序方式	稳定性
插入排序	O(n2)	O(n)	O(n2)	O(1)	In-place	稳定

3.代码实现

def insertSort(arr):
    # 第一层for表示循环插入的遍数
    for i in range(1,len(arr)):
        # 与当前元素比较的比较元素
        preIndex = i-1
        # 设置当前需要插入的元素
        current = arr[i]
        while preIndex >= 0 and arr[preIndex] > current:
            # 当比较元素大于当前元素则把比较元素后移
            arr[preIndex+1] = arr[preIndex]
            # 往前选择下一个比较元素
            preIndex -= 1
        # 当比较元素小于当前元素，则将当前元素插入在 其后面
        arr[preIndex+1] = current
    return arr

四、归并排序

1.算法步骤

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置；
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
4. 重复步骤 3 直到某一指针达到序列尾；
5. 将另一序列剩下的所有元素直接复制到合并序列尾。

2.关于复杂度

排序算法	平均时间复杂度	最好情况	最坏情况	空间复杂度	排序方式	稳定性
归并排序	O(n log n)	O(n log n)	O(n log n)	O(n)	Out-place	稳定

3.代码实现

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

五、快速排序

1.算法步骤

1. 从数列中挑出一个元素，称为 “基准”（pivot）;
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序； 递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

归并排序与快排
1.归并排序与快排两种排序思想都是分而治之，但是它们分解和合并的策略不一样：归并是从中间直接将数列分成两个，而快排是比较后将小的放左边大的放右边，所以在合并的时候归并排序还是需要将两个数列重新再次排序，而快排则是直接合并不再需要排序，所以快排比归并排序更高效一些，可以从示意图中比较二者之间的区别。
2. 快速排序有一个缺点就是对于小规模的数据集性能不是很好

2.关于复杂度

排序算法	平均时间复杂度	最好情况	最坏情况	空间复杂度	排序方式	稳定性
快速排序	O(n log n)	O(n log n)	O(n2)	O(log n)	In-place	不稳定

3.代码实现

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]

其他方式快排：

# 一行代码实现
quick_sort = lambda array: array if len(array) <= 1 else quick_sort([item for item in array[1:] if item <= array[0]]) + [array[0]] + quick_sort([item for item in array[1:] if item > array[0]])
print(quick_sort([3,2,1]))

# 简洁方式
def quecksort_breif(a):
    # 确定基条件
    if len(a) < 2:
        return a
    else:
        # 选择基准
        povit = a[0]

        # 确定基准的左边
        less = [i for i in a[1:] if i <= povit]

        # 确定基准的右边
        greater = [i for i in a[1:] if i > povit]

        # 递归调用
        return quecksort_breif(less) + [povit] + quecksort_breif(greater)