选择排序（selection_sort）——Python实现

 

# 选择排序

# 作用：对给出的n个顺序不定的数进行排序

# 输入：任意数组A

# 输出：按顺序排列的数组A

# 时间复杂度 (n(n-1))/2

# 选择排序

# 第一趟：选择第一个元素，依次与每个元素比较，用k记录下最小的元素的位置，

#           然后第一个元素与最小的元素交换，此时第一个元素变为最小

# 第二趟：选择第二个元素，依次与除了第一个之外的每个元素比较，用k记录下最小的元素的位置，

#           然后第二个元素与最小的元素交换，此时第二个元素变为除第一个之外的最小

# 以此类推，进行n趟后，得到结果

 

 1 # 在此修改初始数据
 2 A = [12,56,92,-1,5,110,92,999,-39,21,76,33,56]
 3 print('初始数据为：');print(A)
 4
 5 n = len(A)          # 用n获取数组长度
 6 i = 0       # 外循环数组元素下标
 7 k = 0       # 内循环的次数，即数组进行k次内循环后前k个数被确定
 8 j = 0       # 内循环数组元素下标
 9
10 while i <= n-1:      # 循环n次
11     while j <= n-1:
12         if A[i] >  A[j]:    # 若大于，则交换，若小于，继续比较下一个
13             temp = A[i]
14             A[i] = A[j]
15             A[j] = temp
16             j = j+1
17         else:
18             j = j+1
19     k = k+1         # 完成一次内循环，则确定一个数
20     i = i+1         # 选择下个元素进行内循环
21     j = k       # 每次循环后将j的值设为k，则下一次循环就不用比较之前已确定的数
22     print(A)    # 查看程序执行过程
23
24 print('调整后的数据为：')
25 print(A)

运行结果：

初始数据为：
[12, 56, 92, -1, 5, 110, 92, 999, -39, 21, 76, 33, 56]
调整后的数据为：
[-39, -1, 5, 12, 21, 33, 56, 56, 76, 92, 92, 110, 999]

选择排序运行过程中数组A的变化情况：

加粗的数表示每一趟确定下来的数，为数组元素的最小值（除了已确定的数）

 1 [-39, 56, 92, 12, 5, 110, 92, 999, -1, 21, 76, 33, 56]
 2 [-39, -1, 92, 56, 12, 110, 92, 999, 5, 21, 76, 33, 56]
 3 [-39, -1, 5, 92, 56, 110, 92, 999, 12, 21, 76, 33, 56]
 4 [-39, -1, 5, 12, 92, 110, 92, 999, 56, 21, 76, 33, 56]
 5 [-39, -1, 5, 12, 21, 110, 92, 999, 92, 56, 76, 33, 56]
 6 [-39, -1, 5, 12, 21, 33, 110, 999, 92, 92, 76, 56, 56]
 7 [-39, -1, 5, 12, 21, 33, 56, 999, 110, 92, 92, 76, 56]
 8 [-39, -1, 5, 12, 21, 33, 56, 56, 999, 110, 92, 92, 76]
 9 [-39, -1, 5, 12, 21, 33, 56, 56, 76, 999, 110, 92, 92]
10 [-39, -1, 5, 12, 21, 33, 56, 56, 76, 92, 999, 110, 92]
11 [-39, -1, 5, 12, 21, 33, 56, 56, 76, 92, 92, 999, 110]
12 [-39, -1, 5, 12, 21, 33, 56, 56, 76, 92, 92, 110, 999]
13 [-39, -1, 5, 12, 21, 33, 56, 56, 76, 92, 92, 110, 999]

简而言之，选择排序过程每次确定一个数，从运行过程上看，很像冒泡排序。

选择排序和冒泡排序的区别是：冒泡排序侧重于“冒泡”，每趟外循环通过冒泡（不断地交换）确定一个数；而选择排序侧重于“选择”，通过比较将指针指向最小的数，然后再做交换。