经典排序算法和Python详解之（一）选择排序和二元选择排序

经典排序算法和Python详解之（一）选择排序和二元选择排序

内容目录

稳定排序和不稳定排序内部排序和外部排序时间复杂度和空间复杂度算法一：选择排序算法二：二元选择排序法（选择排序改进）

排序算法是《数据结构与算法》中最基本的算法之一。排序就是对于一个列表，按照某关键字递增或递减的顺序进行操作。

稳定排序和不稳定排序

稳定排序：经过某种排序后，如果两个记录序号同等，且两者在原无序记录中的先后秩序依然保持不变。如：冒泡排序，归并排序、插入排序、计数排序。

不稳定排序：经过排序后，序号相等，前后秩序有变化。如：快速排序、选择排序、希尔排序、堆排序。

下面简单介绍一下稳定排序和不稳定排序的实际区别： 如果一个列表是[2，1，3，5，6，2]，对应的序号为a0: 2, a1: 1, a2: 3, a3: 5, a4: 6, a5: 2 。 稳定排序的结果：[1，2，2，3，5，6]，对应的序号为：a1, a0, a5, a2, a3, a4。 不稳定排序的结果：[1，2，2，3，5，6]，对应的序号为：a1, a5, a0, a2, a3, a4。 可以看出，经过稳定排序后相等的数排序后其前后顺序是不变的，而不稳定排序后其前后顺序是变化的。

那又会有人问了，既然排序结果一样为什么非要区分稳定排序和不稳定排序呢，其实仔细分析就会恍然大悟，排序结果表面看起来一样，但其实是不一样的，我们举个例子：班级每月一次考试，某一次考完之后需要对学生的成绩进行排名（为了简单我们假设只有4名同学），A：70分，B：80分，C：80分，D：90分。此时排序的时候分数排名为70分，80分，80分，90分。但同样都是80分，到底B和C谁在前面，老师也很纠结，这时比较公平的方法就是稳定排序，如果分数一样，谁上次考试排名靠前那么这次也靠前，激励大家每次都能考高分。也就是稳定排序可以让第一次排序的结果服务于第二次排序中数值相等的那些数。

内部排序和外部排序

内部排序：数据记录在内存中进行排序。 外部排序：因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

通常讨论的排序方法都是内排序，如：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、计数排序等。

时间复杂度和空间复杂度

影响排序算法性能的三个因素： 时间复杂度：即时间性能，高效率的排序算法应该是具有尽可能少的关键字比较次数和记录的移动次数 空间复杂度：主要是执行算法所需要的辅助空间，越少越好。 算法复杂性。主要是指代码的复杂性。

用一张图概括：

其中n是数据规模，k是桶的个数，In-place是占用常数内存，不占用额外内存，Out-place是占用额外内存。 首先定义交换任意两项位置的函数swap：

def swap(x,i,j):
    '''
    交换x的i,j位置元素
    '''
    temp = x[i]
    x[i] = x[j]
    x[j] = temp

算法一：选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法。无论数据什么样，时间复杂度都是O（n^2）， 因此数据规模越小越好，好处就是不占用额外内存。

Python代码：

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

例如待排序列表是[2，3，4，1，5]一共5个数，我们实际分析一下以上代码，对i进行从0到5-1 (0-1-2-3)的遍历，对j进行从i+1到5 (…..4)的遍历，来寻找列表的最小值。

当i = 0，minindex = 0，当j = i+1 = 1, list[1] = 3 > list[0] = 2, minindex不变。 当j = i+2 = 2, list[2] = 4 > list[0] = 2, minindex 不变。 当j = j+3 = 3, list[3] = 1 < list[0] = 2, minindex = 3。当j = j+4 = 4, list[4] = 5 > list[3] = 1, minindex不变，最终minindex = 3。

此时i = 0 != minindex = 3, 交换两项，list[0]和list[3]，最后列表变为：[1,3,4,2,5],查找出的最小值放在起始位置，再从剩余列表继续查找最小值。

当i = 1，minindex = 1，继续遍历j，简单说，当j = i+2 = 3, list[3] = 1 < list[1] = 3, minindex = 3。

此时i = 1 != minindex = 3, 交换两项，list[1]和list[3], 最后列表变为：[1，2，4，3，5]。

当i = 2, minindex = 2, 继续遍历j，简单说，当j = i+1 = 3, list[3] = 3 < list[2] = 4, minindex = 3。

此时i = 2 != minindex = 3, 交换两项，list[2] 和list[3], 最后列表变为：[1，2，3，4，5]。

当i = 3, minindex = 3, 继续遍历j，j只有等于4，list[4] = 5 大于list[3] = 4，minindex = 3还是初始值。

此时i = 3 == minindex = 3, 不用做交换，遍历结束，最后列表排序结果为：[1，2，3，4，5]。

代码里用到了两个for循环，因此时间复杂度为O（n^2）。

算法二：二元选择排序法（选择排序改进）

选择排序法每轮只找最小值，效率较低，可以考虑每次同时寻找最小值和最大值，并且在某一轮如果最小值与最大值相同，说明剩下的数都相同，可以直接结束。 此外，与选择排序不同的是，需要考虑到如果第i轮里，恰好第i个数就是最大值时，先交换minindex和i之后，最大值的下标变成了minindex，这时候应该交换minindex和n-i-1，而不是maxindex和n-i-1。

Python代码：

def selectionSort_1(x):
   i = 0
   while i <= len(x) // 2:###两侧一起向中心移动，因此为一半
       minindex = i
       maxindex = i
       j = i + 1
       while j < len(x) - i  :
           if x[minindex] > x[j]:
               minindex = j
           if x[maxindex] < x[j]:
               maxindex = j
           j+= 1
       if x[minindex] == x[maxindex]:
           return x 
       if minindex != i:
           swap(x,i,minindex)
       if maxindex != len(x) - 1 - i :
           if maxindex != i:
               swap(x,len(x) - 1 - i,maxindex)
           else:
               swap(x,len(x) - 1 - i, minindex)
       i += 1 
   return x

举例待排序列表是[2，3，4，1，5，6]一共6个数，我们实际分析一下以上代码，因为要从两侧同时向中心查找，因此i只需要遍历列表的一半。

当i = 0, 此时i <= len(list)//2 = 3，minindex = 0，maxindex = 0, j = i+1 = 1, 判断j = 1 < len(list) – i = 6-0=6, 判断list[minindex=0] = 2 < list[j=1] = 3, minindex=0不变。判断list[maxindex=0] = 2 < list[j=1]=3,maxindex = 1。

j + 1 = 2, 判断j = 2 < len(list) – i = 6-0=6, 判断list[minindex=0] = 2 < list[j=2] = 4, minindex=0不变。判断list[maxindex=1] = 3 < list[j=2]=4, maxindex = 2。

j + 1 = 3, 判断j = 3 < len(list) – i = 6-0=6, 判断list[minindex=0] = 2 > list[j=3] = 1, minindex=j=3。判断list[maxindex=2] = 4 > list[j=3]=1, maxindex = 2保持不变。

j + 1 = 4, 判断j = 4 < len(list) – i = 6-0=6, 判断list[minindex=3] = 1< list[j=4] = 5, minindex=3保持不变。判断list[maxindex=2] = 4 < list[j=4]=5, maxindex = j = 4。

j + 1 = 5, 判断j = 5 < len(list) – i = 6-0=6, 判断list[minindex=3] = 1< list[j=5] = 6, minindex=3保持不变。判断list[maxindex=4] = 5 < list[j=5]=6, maxindex = j = 5。

这样就当i=0时，同时找到一个最大值和一个最小值。判断list[minindex = 3] = 1, list[maxindex= 5]=6, 两者不相等。 判断minindex = 3 != i = 0, 交换list[i]和list[minindex],此时list = [1，3，4，2，5，6]。 判断maxindex = 5 == len(list) -1 – i = 5, i = i + 1 = 1。

当i = 1, 判断i <= len(list)//2 = 3，minindex = 1，maxindex = 1, j = i+1 = 2, 判断j = 2 < len(list) – i = 6-1=5, 判断list[minindex=1] = 3 < list[j=2] = 4, minindex=1不变。此时 list[maxindex=1] = 3 < list[j=2]=4, maxindex = j = 2。

j = j+1 = 3, 判断j = 3 < len(list) – i = 6-1=5, 判断list[minindex=1] = 3 > list[j=3] = 2, minindex=j=3。判断list[maxindex=2] = 4 > list[j=3]=2, maxindex = 2保持不变。

j = j+1 = 4, 判断j = 4 < len(list) – i = 6-1=5, 判断list[minindex=3] = 2 < list[j=4] = 5, minindex=3保持不变。判断list[maxindex=2] = 4 < list[j=4]=5, maxindex = j = 4。

这样就当i=1时，同时找到一个最大值和一个最小值。判断list[minindex = 3] = 2, list[maxindex= 4]=5, 两者不相等。 判断minindex = 3 != i = 1, 交换list[i]和list[minindex],此时list = [1，2，4，3，5，6]。 判断maxindex = 4 == len(list) -1 – i = 4, i = i + 1 = 2。

当i = 2, 判断i <= len(list)//2 = 3，minindex = 2，maxindex = 2, j = i+1 = 3, 判断j = 3 < len(list) – i = 6-2=4, 判断list[minindex=2] = 4 > list[j=3] = 3, minindex=j = 3。此时 list[maxindex=2] = 4 > list[j=3]=3, maxindex = 2保持不变。

j = j+1 = 4, 判断j = 4 == len(list) – i = 6-2=4, 这样就当i=1时，同时找到一个最大值和一个最小值。判断list[minindex = 3] = 3, list[maxindex= 2]=4, 两者不相等。

判断minindex = 3 != i = 2, 交换list[i=2]和list[minindex=3],此时list = [1，2，3，4，5，6]。 判断maxindex = 2 != len(list) -1 – 2 = 3, 判断maxindex = 2 == i = 2, 交换list[len(list)-1-i=3]和list[minindex = 3]，也就是没交换。 最终的排序结果是[1，2，3，4，5，6]。