用 Python 实现冒泡，选择，快排。

1.冒泡排序

原理：相邻元素相比较， 小的放在左边，大的放右边。

思路：依次比较相邻的两个元素， 大的放在右边。第 1 个数和第 2 个数比较， 大的放在右边，第 2 个和第 3 个比较， 大的放右边， 以此类推。第一遍结束， 最大的在最右边。在一论循环，除去最右边的的最大的放在右边第二个，类推即可排序。

代码：

def bubble_sort(my_list):
    length = len(my_list)
    for i in range(length - 1, -1, -1):
        for j in range(0, i):
            if my_list[j] > my_list[j + 1]:
                exchange = my_list[j]
                my_list[j] = my_list[j + 1]
                my_list[j + 1] = exchange


my_list = [7, 9, 2, 6, 1, 5, -3, 2]
bubble_sort(my_list)
print(my_list)

时间复杂度： 最好情况， 若数组是正序，此时只需便利一边就可以了，所以最好时间复杂度是 o(n). 最坏情况是反序也就是需要全部走一遍， 所以时间复杂度为 O(n^2), 平均时间复杂度为 O(n^2)。

空间复杂度： O(1)

2. 选择排序

原理：通俗说就是每次循环把最小的放在最左边， 第一次循环放在左边， 第二次把剩下的循环得到第二小的放在最小的右边。

思路：第一次循环把第一个数记下， 依次和剩余的数比较，比他小的就交换，比较下来第一位就是最小的数。第二次循环把第二个数和除去第一个数和自己所有的数比较， 比第二个数小的就交换。以此类推即可。

代码：

def selection_sort(my_list):
    length = len(my_list)
    for i in range(length-1):
        num = my_list[i]
        index = i
        for j in range(i+1, length):
            if my_list[j] < num:
                num = my_list[j]
                index = j
        if i != index:
            exchange = my_list[index]
            my_list[index] = my_list[i]
            my_list[i] = exchange


my_list = [7, 9, 2, 6, 1, 5, -3, 2, 5]
selection_sort(my_list)
print(my_list)

时间复杂度： 无论最好还是最坏都需要把循环做完， 所以时间复杂度都是  O(n^2)。

空间复杂度： O(1)。

3. 快速排序.

原理： 设定一个中间数， 把比他小的放在他左边， 大的放在他右边， 递归便可以排好序。

思路： 设定第一个数为中间数，相当于给索引 1 挖了一个坑， 然后从最右边开始比中间数大的就滤过，比中间数小的就把这个数放在挖的那个坑里，同时自身也会出现一个坑。此时从左边开始遍历， 把比中间数小的滤过， 大的就放在右边那个坑里，再去右边去遍历， 比中间数小的再放左边那个坑里， 这样下去左边都小于或者等于比中间数，右边都大于或等于中间数。把数组分成两部分了这样， 在递归，就可以了。

代码：

def quick_sort(my_list, x, y):
    middle_num = my_list[x]
    while x < y:
        while x < y and my_list[y] >= middle_num:
            y -= 1
        my_list[x] = my_list[y]
        while x < y and my_list[x] <= middle_num:
            x += 1
        my_list[y] = my_list[x]
    my_list[x] = middle_num
    return x


def recursion(my_list, x, y):
    if x < y:
        middle = quick_sort(my_list, x, y)
        recursion(my_list, x, middle - 1)
        recursion(my_list, middle + 1, y)


my_list = [7, 9, 2, 6, 1, 5, -3, 2, 5]
recursion(my_list, 0, len(my_list)-1)
print(my_list)

时间复杂度： 最好情况是  O(nlogn), 最坏情况  O(n^2),  平均时间复杂度 O(nlogn)。

空间复杂度： O（logn）