面试：java 选择排序

**算法描述**

1. 将数组分为两个子集，排序的和未排序的，每一轮从未排序的子集中选出最小的元素，放入排序子集

2. 重复以上步骤，直到整个数组有序

    public static void main(String[] args) {
        int[] a = {5, 3, 7, 2, 1, 9, 8, 4};

        for (int i = 0; i < a.length - 1; i++) {
            // i 代表每轮选择，最小元素要交换到的目标索引
            int s = i; // 代表最小元素的索引
            for (int j = s + 1; j < a.length; j++) {
                if (a[s] > a[j]) { // j 元素比 s 元素还要小, 更新 s
                    s = j;
                }
            }
            if (s != i) {
                swap(a, s, i);
            }
            System.out.println(Arrays.toString(a));
        }
    }

    public static void swap(int[] a, int i, int j) {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }


控制台输出：
[1, 3, 7, 2, 5, 9, 8, 4]
[1, 2, 7, 3, 5, 9, 8, 4]
[1, 2, 3, 7, 5, 9, 8, 4]
[1, 2, 3, 4, 5, 9, 8, 7]
[1, 2, 3, 4, 5, 9, 8, 7]
[1, 2, 3, 4, 5, 7, 8, 9]
[1, 2, 3, 4, 5, 7, 8, 9]

* 优化点：为减少交换次数，每一轮可以先找最小的索引，在每轮最后再交换元素

**与冒泡排序比较**

1. 二者平均时间复杂度都是 $O(n^2)$

2. 选择排序一般要快于冒泡，因为其交换次数少

两者比较次数差不多，但是交换次数不同，选择排序每轮选择最多一次交换，而冒泡排序，每次冒泡，只要后一个比前一个大，都要发生一次交换

3. 但如果集合有序度高，冒泡优于选择

冒泡排序可以通过判断是否需要交换，判断出集合是否有序，有没有必要进行下一次冒泡，假如集合是有序的，一轮就可以；

4. 冒泡属于稳定排序算法，而选择属于不稳定排序
   * 稳定排序指，按对象中不同字段进行多次排序，不会打乱同值元素的顺序
   * 不稳定排序则反之

以扑克牌排序为例

都是先按照花色排序（♠♥♣♦），再按照数字排序（AKQJ...）

* 不稳定排序算法按数字排序时，会打乱原本同值的花色顺序
  [[♠7], [♠2], [♠4], [♠5], [♥2], [♥5]]
  [[♠7], [♠5], [♥5], [♠4], [♥2], [♠2]]

  原来 ♠2 在前 ♥2 在后，按数字再排后，他俩的位置变了

* 稳定排序算法按数字排序时，会保留原本同值的花色顺序，如下所示 ♠2 与 ♥2 的相对位置不变
  [[♠7], [♠2], [♠4], [♠5], [♥2], [♥5]]
  [[♠7], [♠5], [♥5], [♠4], [♠2], [♥2]]

面试题：数组18 23 19 9 23 15，使用选择排序算法，第三轮排序后的结果是

第一轮：9 23 19 18 23 15

第二轮：9 15 19 18 23 23

第三轮：9 15 18 19 23 23