算法是程序的灵魂之选泡插

一，选择排序(selection sort)

选择排序是最简单的也是相对来说最鸡肋排序算法，有一定的优化空间。

简单就不用多讲，为啥说其‘鸡肋’呢？因为它的时间复杂度为O(n^2)，还不稳定！

工作原理如下：

首先在未排序的序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对n个元素的表进行排序总共进行至多(n-1)次交换。

基于python的示例：

import random


def selection_sort(new_list):  # 不推荐的写法
    another_list = []  # 定义一个新列表
    for i in range(len(new_list)):  # 求出要排序列表的长度，也就是要循环的次数
        min_number = min(new_list)  # 每次循环求出列表中的最小值
        another_list.append(min_number)  # 每次循环将最小值添加到新列表中
        new_list.remove(min_number)  # 删除原列表中每次循环的最小值
    return another_list

selection_list = [random.randint(-100, 100) for i in range(20)]
print('\033[31;1m未排序>>>:\033[0m', selection_list)
another_list = selection_sort(selection_list)
print('\033[32;1m从小到大已排序>>>:\033[0m', another_list)

推荐如下写法：

import random


def selection_better_sort(new_list):
    n = len(new_list)
    for i in range(n - 1):
        min_loc = i
        for j in range(i + 1, n):
            if new_list[j] < new_list[min_loc]:
                min_loc = j
        new_list[i], new_list[min_loc] = new_list[min_loc], new_list[i]


selection_list = [random.randint(-100, 100) for i in range(20)]
print('\033[31;1m未排序>>>:\033[0m', selection_list)
selection_better_sort(selection_list)
print('\033[32;1m从小到大已排序>>>:\033[0m', selection_list)

复杂度：

选择排序的平均时间复杂度, 最坏时间复杂度, 最好时间复杂度都为O(n^2)， 空间复杂度为O(1)。

（注：若想了解更多编程语言的选择排序，推荐去维基百科；或者输入www.bing.com进入必应搜索，选择国际版进行搜索）

二，冒泡排序(bubble sort)

冒泡排序又称为泡式排序，是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

冒泡排序算法的运作如下：

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

基于python的示例：

import random


def bubble_sort(new_list):  # 从小到大排列
    n = len(new_list)
    for i in range(n - 1):
        for j in range(n - 1 - i):
            if new_list[j] > new_list[j + 1]:  # 若想从大到小排，只需将此行 > 换成 < 即可
                new_list[j], new_list[j + 1] = new_list[j + 1], new_list[j]


bubble_list = [random.randint(-100, 100) for i in range(20)]
print('\033[31;1m未排序>>>:\033[0m', bubble_list)
bubble_sort(bubble_list)
print('\033[32;1m从小到大已排序>>>:\033[0m', bubble_list)

假如在循环未结束前，内部就已经没有了元素交换，那么说明在没有元素交换时就已经排好序了，对此进行一点小优化：

import random


def bubble_better_sort(new_list):  # 从小到大排列(一点小优化)
    n = len(new_list)
    for i in range(n - 1):
        exchange = 0
        for j in range(n - 1 - i):
            if new_list[j] > new_list[j + 1]:
                new_list[j], new_list[j + 1] = new_list[j + 1], new_list[j]
                exchange = 1
        # print('中间的交换步骤>>>:', new_list)
        if exchange == 0:
            return new_list


bubble_list = [random.randint(-100, 100) for i in range(10)]
print('\033[31;1m未排序>>>:\033[0m', bubble_list)
bubble_better_sort(bubble_list)
print('\033[32;1m从小到大已排序>>>:\033[0m', bubble_list)

复杂度：

冒泡排序的平均时间复杂度和最坏时间复杂度为O(n^2)，最好时间复杂度为O(n)，空间复杂度为O(1)。

冒泡排序是稳定的。

三，插入排序(insertion sort)

插入排序是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

算法：

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

1，从第一个元素开始，该元素可以认为已经被排序
2，取出下一个元素，在已经排序的元素序列中从后向前扫描
3，如果该元素（已排序）大于新元素，将该元素移到下一位置
4，重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5，将新元素插入到该位置后
6，重复步骤2~5

基于python的示例：

import random


def insertion_sort(new_list):
    for i in range(1, len(new_list)):
        while i > 0 and new_list[i - 1] > new_list[i]:
            new_list[i], new_list[i - 1] = new_list[i - 1], new_list[i]
            i -= 1


insertion_list = [random.randint(-100, 100) for i in range(20)]
print('\033[31;1m未排序>>>:\033[0m', insertion_list)
insertion_sort(insertion_list)
print('\033[32;1m从小到大已排序>>>:\033[0m', insertion_list)

复杂度：

插入排序的平均时间复杂度和最坏时间复杂度为O(n^2)，最好时间复杂度为O(n)，空间复杂度为O(1)。

插入排序是稳定的！