大学之道 - 算法

Posted 2021-02-21 samnicole1809

1、选择排序

 1 public class SelectSort<T extends Comparable> {
 2 
 3     public void sort(T[] arr) {
 4         if (arr != null && arr.length > 1) {
 5             for (int i = 0; i < arr.length; i++) {
 6                 // 输出排序情况
 7                 for (T in : arr) {
 8                     System.out.print(in);
 9                 }
10                 System.out.println();
11                 int index = i;
12                 T min = arr[i];
13                 // 找未排序部分的最小值
14                 for (int j = i + 1; j < arr.length; j++) {
15                     if (arr[j].compareTo(min) < 0) {
16                         min = arr[j];
17                         index = j;
18                     }
19                 }
20                 // 交换
21                 if (index != i) {
22                     arr[index] = arr[i];
23                     arr[i] = min;
24                 }
25             }
26         }
27     }
28 
29     public static void main(String[] args) {
30         Integer[] arr = new Integer[]{1, 3, 8, 7, 6, 9, 5, 4, 3, 2, 0};
31         SelectSort ss = new SelectSort();
32         ss.sort(arr);
33     }
34 
35     /**
36      * 13876954320 -> 原数组，长度11
37      * ^         ^ ->
38      * 03876954321 遍历了10 -> 第一次交换，交换完3的原顺序变了，因此不稳定
39      *  ^        ^
40      * 01876954323 遍历了9 -> 第二次交换
41      *   ^      ^
42      * 01276954383 遍历了8 -> 第三次交换
43      *    ^    ^
44      * 01236954783 遍历了7 -> 第四次交换
45      *     ^     ^
46      * 01233954786 遍历了6 -> 第五次交换
47      *      ^ ^
48      * 01233459786 遍历了5 -> 第六次交换（未交换）
49      *       ^
50      * 01233459786 遍历了4 -> 第七次交换
51      *        ^  ^
52      * 01233456789 遍历了3 -> 第八次交换（未交换）
53      *         ^
54      * 01233456789 遍历了2 -> 第九次交换（未交换）
55      *          ^
56      * 01233456789 遍历了1 -> 第十次交换（未交换）
57      *           ^
58      *
59      * 想当于最外层遍历了11次，内层遍历了10 + 9 + ... + 2 + 1次
60      * => 遍历次数：n(n - 1)/2
61      * => 时间复杂度：O(n2)
62      * => 稳定性：不稳定
63      */
64 }