Python实现常见排序算法上

一、选择排序

　　选择排序（ Selection Sort ）是一种简单直观的排序算法，基本原理：首先在未排序中找到最小（大）的元素，存放在排序序列的起始位置，然后在从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序的末尾，一次类推，直到所有元素均排序完毕。

　　选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个呗移到其最终位置上，因此对 n 个元素的表进行排序共进行至多 n - 1次交换。在所有完成依靠交换去移动元素的排序方法中，选择排序属于非常好的一种。

　　

　　1、排序过程，图示（图来源网络）：

　　　　假设右边为已排序，然后从左边未排序中选择一个最大值，放到右边来。

　　　　

　　　　

 

 

　　2、python实现过程：

　　　　这里代码的思想为：假设左边为已排序，右边为排序。

# coding=utf-8


def selection_sort(ls):
    """选择排序"""
    # 假设左边为已排序，右边为未排序

    print("before：", ls)
    for i in range(0, len(ls) - 1):
        # i = [0, 1, 2,,, len(ls) - 2]
        # j = [i + 1, i + 2,,, len(ls) - 1]
        min_index = i
        for j in range(i + 1, len(ls)):
            if ls[j] < ls[min_index]:
                min_index = j

        if min_index != i:
            ls[min_index], ls[i] = ls[i], ls[min_index]
        print(ls)
    print("after：", ls)


if __name__ == "__main__":
    ls = [54, 26, 93, 17, 77, 31, 44, 55, 20]

    selection_sort(ls)

3、时间复杂度：

　　　　最优时间复杂度：O(n2)

　　　　最坏时间复杂度：O(n2)

　　　　稳定性：不稳定（考虑升序每次选择最大的情况）

二、冒泡排序

　　冒泡排序（Bubble Sort）算是一种比较常见的排序算法，重复遍历要排序的数列，一次比较相邻的两个元素，如果顺序错误即互相交换位置，遍历直到无需再交换，则此时数列已经排序完成。此算法名字由来：因为越小的元素（升序）经由交换慢慢 “浮”到数列的顶端。

　　1、冒泡排序的基本思想（原理）：

　　　   · 比较相邻的元素，如果第一个比第二个大（升序），就交换它们两个。

　　　　· 对每一对相邻的元素作同样的工作，从开始第一对到结尾最后一对，这一步做完后，最后的元素会是最大的数。

　　　　· 针对所有的元素重复以上的步骤，除了最后一个（倒数第二个与其已作比较）。

　　　　· 持续每次对越来越少的元素重复上面的步骤，知道没有任何一对数字需要比较。

　　　　

　　　　交换过程示意图（第一次）（来自网络）：

　　　　

 

　　　　

　　2、python实现过程：

　　　　这里提供两种实现过程，第二个实现过程为上面示意图所示。　

# coding=utf-8


def bubble_sort(ls):
    """冒泡排序"""
    print("before: ", ls)
    for i in range(0, len(ls) - 1):
        # i = [0, 1, ...., len(ls) - 2]，每次比较的第一个数的下标
        # j = [i + 1, i + 2, ..., len(ls) - 1]，每次比较的第二个数的下标
        for j in range(i + 1, len(ls)):
            if ls[i] > ls[j]:
                ls[i], ls[j] = ls[j], ls[i]
        print(ls)
    print("after: ", ls)


def bubble_sort2(ls):
    """冒泡排序"""
    print("before：", ls)
    for j in range(len(ls) - 1, 0, -1):
        # j = [len(ls) - 1, len(ls) - 2, ..., 1], 每次需要比较的次数
        # i = [0, 1, 2, ..., j - 1]，需要比较的下标
        for i in range(j):
            if ls[i] > ls[i + 1]:
                ls[i], ls[i + 1] = ls[i + 1], ls[i]
        print(ls)
    print("after：", ls)


if __name__ == "__main__":
    ls1 = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    ls2 = [54, 26, 93, 17, 77, 31, 44, 55, 20]

    bubble_sort(ls1)
    print("-"*50)
    bubble_sort2(ls2)

执行结果（分割线上为 bubble_sort1() 的执行结果，分割线下为 bubble_sort2() 的执行结果）：

　　　　

　　

　　3、时间复杂度：

　　　　最优时间复杂度：O(n)（表示遍历一次发现没有任何可以交换的元素排序结束，在内循环可以做一个标识判断，如果首次循环没有任何交换，则跳出）

　　　　最坏复杂度：O(n2)

　　　　稳定性：稳定

三、插入排序

　　插入排序（Insert ion Sort），其工作原理：通过构建有序序列，对于未排序数据中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后面向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

　　

　　1、排序过程，图示意（图片来自网络）：

　　　　

 

　　　　　

　　　　

　　2、python实现过程：

　　　　从小标为 1 开始，往 0 遍历，比较交换。

# coding=utf-8


def insert_sort(ls):
    """插入排序"""
    # 假设左边已排序，右边为未排序，每次从右边取一个数，遍历已排序的子序列，直到找到次数的位置。
    print("before: ", ls)
    for j in range(1, len(ls)):
        for i in range(j, 0, - 1):
            if ls[i] < ls[i - 1]:
                ls[i], ls[i - 1] = ls[i - 1], ls[i]
        print(ls)
    print("after: ", ls)


if __name__ == "__main__":
    ls = [54, 26, 93, 17, 77, 31, 44, 55, 20]

    insert_sort(ls)

执行结果：

　　　　

　　　　

　　3、时间复杂度：

　　　　最优时间复杂度：O(n)（升序序列，序列已经处于升序状态）

　　　　最坏时间复杂度：O(n2)

　　　　稳定性：稳定

四、希尔排序

　　希尔排序（Shell Sort）是插入排序的一种。也称为增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是把纪录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个序列恰被分成一组，算法便终止。

　　

　　1、希尔排序过程：

　　　　基本思想：将数组列在一个表中并对列分别进行插入排序，重复这过程，不过每次用更长的列（步长更长了，列数更少了）来进行。最后整个表就只有一列了。将数组转换至表识为了更好理解这算法，算法本身还是使用数组进行排序。

　　　　例如，假设有这样一组数[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我们以步长为5开始进行排序，我们可以通过将这列表放在有5列的表中进行更好的描述算法，这样它们就应该看起来是这样（竖着的元素是步长组成）：

　　　　

　　　　最后以 1 步长进行排序（此时就是简单的插入排序）

　　　　　

　　　　

　　2、python实现过程：

　　　　实现过程基本和插入排序类似，只是插入排序的 step 固定为 1，而希尔排序的 step 会变化直至 为 1。

# coding=utf-8


def shell_sort(ls):
    """希尔排序"""
    print("before: ", ls)

    step = len(ls) // 2     # 初始步长

    while step > 0:
        # 插入排序
        for j in range(step, len(ls)):
            for i in range(j, 0, - step):
                if ls[i] < ls[i - step]:
                    ls[i], ls[i - step] = ls[i - step], ls[i]
        step //= 2
        print(ls)
    print("shell_sort ：", ls)


if __name__ == "__main__":
    ls = [54, 26, 93, 17, 77, 31, 44, 55, 20]

    shell_sort(ls)

　执行结果：

　　　　

 　

　　3、时间复杂度：

　　　　最优时间复杂度：根据步长序列的不同而不同。

　　　　最坏时间复杂度：O(n2)。

　　　　稳定性：不稳定。