标签：min led bsp art public 思路分析 info code rgs
选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到排序的目的。
选择排序（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次，得到一个按排序码从小到大排列的有序序列
请使用选择排序从低到高进行排序 [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 比较中的 > 换成 < 即可。
标签：min led bsp art public 思路分析 info code rgs
原文地址：https://www.cnblogs.com/niujifei/p/13256228.html
