排序算法——选择排序

Posted 2020-12-15 niujifei

一、选择排序介绍

　　1、基本介绍

　　　　选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到排序的目的。

　　2、选择排序思想

 　　　　选择排序（select sorting）也是一种简单的排序方法。它的基本思想是：

　　　　　　第一次从arr[0]~arr[n-1]中选取最小值，与arr[0]交换，

　　　　　　第二次从arr[1]~arr[n-1]中选取最小值，与arr[1]交换，

　　　　　　第三次从arr[2]~arr[n-1]中选取最小值，与arr[2]交换，…，

　　　　　　第i次从arr[i-1]~arr[n-1]中选取最小值，与arr[i-1]交换，…,

　　　　　　第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列

　　3、选择排序思路分析图

　　　　

 

 　　　　 

二、选择排序实现

　　请使用选择排序从低到高进行排序 [101, 34, 119, 1]

 

　　推导过程：

 1 public static void selectSort(int[] arr) {
 2         
 3         // 原始的数组 ： 101,34,119,1
 4 
 5         // 第1轮 排序 ： 1,34,119,101
 6         // 第一轮排序
 7         int minIndex = 0;  //假设第一个为最小值，并记录最小的下标
 8         int min = arr[0];  //假设第一个为最小值
 9         for (int j = 0 + 1; j < arr.length; j++) {
10             if (min > arr[j]) {
11                 min = arr[j];  //重置最小值
12                 minIndex = j;  //重置最小值的下标
13             }
14         }
15         
16         // 交换，将最小值，放在 arr[0] 位置，即交换，
17         arr[minIndex] = arr[0];
18         arr[0] = min;
19         System.out.println("第一轮后：" + Arrays.toString(arr));
20         
21         // 第二轮排序
22         minIndex = 1;  //假设第一个为最小值，并记录最小的下标
23         min = arr[1];  //假设第一个为最小值
24         for (int j = 1 + 1; j < arr.length; j++) {
25             if (min > arr[j]) {
26                 min = arr[j];  //重置最小值
27                 minIndex = j;  //重置最小值的下标
28             }
29         }
30         
31         // 交换，将最小值，放在 arr[0]位置，即交换，
32         //在这里发现，最小值的下标就是我们假设的值，那么就不用进行交换了【优化】
33         if (minIndex != 1) {
34             arr[minIndex] = arr[1];
35             arr[1] = min;
36         }
37         System.out.println("第二轮后：" + Arrays.toString(arr));
38         
39         // 第三轮排序
40         minIndex = 2;  //假设第一个为最小值，并记录最小的下标
41         min = arr[2];  //假设第一个为最小值
42         for (int j = 2 + 1; j < arr.length; j++) {
43             if (min > arr[j]) {
44                 min = arr[j];  //重置最小值
45                 minIndex = j;  //重置最小值的下标
46             }
47         }
48         
49         // 交换，将最小值，放在 arr[0]位置，即交换，
50         //在这里发现，最小值的下标就是我们假设的值，那么就不用进行交换了【优化】
51         if (minIndex != 2) {
52             arr[minIndex] = arr[2];
53             arr[2] = min;
54         }
55         System.out.println("第三轮后：" + Arrays.toString(arr));
56     }

 

　　封装方法：

 1 public static void selectSort(int[] arr) {
 2         
 3         for (int i = 0; i < arr.length - 1; i++) {
 4             int minIndex = i;
 5             int min = arr[i];
 6             
 7             for (int j = i + 1; j < arr.length; j++) {
 8                 if (min > arr[j]) {
 9                     minIndex = j;  //重置最小值的下标
10                     min = arr[j];  //重置最小值
11                 }
12             }
13             
14             //判断当前最小值是否是自己，如果不是，则进行交换
15             if (minIndex != i) {
16                 arr[minIndex] = arr[i];
17                 arr[i] = min;
18             }
19             System.out.println("第" +(i+1)+"轮后：" + Arrays.toString(arr));
20         }
21     }

 

　　测试：

 1 public static void main(String[] args) {
 2         
 3         //创建80000个随机的数组
 4         int[] arr = new int[80000];
 5         for (int i = 0; i < 80000; i++) {
 6             arr[i] = (int)(Math.random() * 800000);
 7         }
 8         
 9         Date date1 = new Date();
10         SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
11         String start = simpleDateFormat.format(date1);
12         System.out.println("排序前：" + start);
13         
14         //测试选择排序
15         selectSort2(arr2);
16         
17         Date date2 = new Date();
18         String end = simpleDateFormat.format(date1);
19         System.out.println("排序后：" + end);
20     }

　　

 　　可以看到使用选择排序对8000个数据排序仅需要1-2秒的时间，因为它不需要频繁的进行换位，它会先进行比较，比较完之后，如果自身不是最小值才进行交换，所以比较节省时间。

 

三、扩展

　　1、如果要对数据从大到小排序呢？

　　　　只需要将 if 比较中的 > 换成 < 即可。