一、前言
简单选择排序是一种选择排序。
选择排序:每趟从待排序的记录中选出关键字最小的记录,顺序放在已排序的记录序列末尾,直到全部排序结束为止。
二、算法思想
简单排序很简单,它的大致处理流程为:
从待排序序列中,找到关键字最小的元素;
如果最小元素不是待排序序列的第一个元素,将其和第一个元素互换;
从余下的 N - 1 个元素中,找出关键字最小的元素,重复(1)、(2)步,直到排序结束。
举例说明,处理过程示意图如下所示:
如图所示,每趟排序中,将当前第 i 小的元素放在位置 i 上。
1、代码
Java:
package test;
/**
* 1.原理:每一趟从待排序的记录中选出最小的元素,顺序放在已排好序的序列最后,直到全部记录排序完毕。
* 也就是:每一趟在n-i+1(i=1,2,…n-1)个记录中选取关键字最小的记录作为有序序列中第i个记录。
* 基于此思想的算法主要有简单选择排序、树型选择排序和堆排序。(这里只介绍常用的简单选择排序)
* 2.简单选择排序的基本思想:给定数组:int[] arr={里面n个数据};
* 第1趟排序,在待排序数据arr[1]~arr[n]中选出最小的数据,将它与arrr[1]交换;
* 第2趟,在待排序数据arr[2]~arr[n]中选出最小的数据,将它与r[2]交换;
* 以此类推,第i趟在待排序数据arr[i]~arr[n]中选出最小的数据,将它与r[i]交换,直到全部排序完成。
*
* 以上为了好理解,从下标1解释的,写的代码是从0开始的。
*/
public class SelectSort {
public static void main(String[] args) {
int[] arr = {9, 1, 2, 5, 7, 4, 8, 6, 3, 5};
//排序前
System.out.println("排序前:");
for(int num:arr)
{
System.out.print(num+" ");
}
//选择排序
selectSort(arr);
//排序后
System.out.println();
System.out.println("排序后:");
for(int num:arr)
{
System.out.print(num+" ");
}
}
//核心代码
public static void selectSort(int[] arr) {
// 要注意一点,当要排序 N 个数,已经经过 N-1 次遍历后,已经是有序数列
for(int i=0;i<arr.length-1;i++)
{
//存储最小元素的索引
int min_index = i;
//进行元素值的大小比较,获得本轮中最小元素的索引(即下标)
for(int j=i+1;j<arr.length;j++)
{
if(arr[j]<arr[min_index])
min_index = j;//小的索引存在min_index里
}
//在内层循环结束,也就是找到本轮循环的最小的数以后,再进行交换
if(min_index!=i)
{ //交换
int temp=arr[i];
arr[i] = arr[min_index];
arr[min_index] = temp;
}
}
}
}
排序前:
9 1 2 5 7 4 8 6 3 5
排序后:
1 2 3 4 5 5 6 7 8 9
Python:
def SelectSort(input_list):
'''
函数说明:简单选择排序(升序)
Parameters:
input_list - 待排序列表
min_index - 临时保存最小元素的索引
temp - 交换辅助
'''
if len(input_list) == 0:
return []
length = len(input_list)
# 外层循环,控制循环的趟数
for i in range(length-1):
# 存储最小元素的索引
min_index = i
# 进行大小比较,获取最小元素的下标
for j in range(i + 1, length):
if input_list[min_index] > input_list[j]:
min_index = j
# 一轮大小比较完毕,现在获得了本轮中最小元素的索引(即下标)
#在内层循环结束,也就是找到本轮循环的最小的数以后,再进行交换
if(i!=min_index):
temp = input_list[i]
input_list[i] = input_list[min_index]
input_list[min_index] = temp
# 输出每一趟的排序结果
print('第%d趟的排序结果:' % (i + 1), input_list)
return input_list
if __name__ == '__main__':
input_list = [9, 1, 2, 5, 7, 4, 8, 6, 3, 5]
print('排序前:', input_list)
sorted_list = SelectSort(input_list)
print('排序后:', sorted_list)
图解算法书上代码:
def findSmallest(arr):
smallest=arr[0]
smallest_index =0
for i in range(1,len(arr)):
if arr[i] <smallest:
smallest=arr[i]
smallest_index=i
return smallest_index
def selectionSort(arr):
newArr=[]
for i in range(len(arr)):
smallest=findSmallest(arr)
newArr.append(arr.pop(smallest))
return newArr
print(selectionSort([5,3,6,2,10]))
三、算法分析
1、简单算法排序性能
其中,N2为N^2。
2、时间复杂度
简单选择排序的比较次数与序列的初始排序无关。 假设待排序的序列有 N 个元素,则比较次数总是N (N - 1) / 2。
而移动次数与序列的初始排序有关。当序列正序时,移动次数最少,为 0.
当序列反序时,移动次数最多,为3N (N - 1) / 2。
所以,综合以上,简单排序的时间复杂度为 O(N^2)。
3、空间复杂度
O(1)
四、小结
计算机内存犹如一大堆抽屉。
需要存储多个元素时,可使用数组或链表。
数组的元素都在一起。
链表的元素是分开的,其中每个元素都存储了下一个元素的地址。
数组的读取速度很快。
链表的插入和删除速度很快。
在同一个数组中,所有元素的类型都必须相同(都为int、double等)。