数据结构与算法之选择排序（含改进版）

选择排序概念

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对n个元素的表进行排序总共进行至多n-1次交换。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于非常好的一种

动图展示：

代码实现

import java.util.Arrays;

public class seletsort {
    public static void main(String[] args) {
        int[] arr = {4, 5, 6, 3, 2, 1};
        selectSort(arr);
//        [1, 5, 6, 3, 2, 4]
//        [1, 2, 6, 3, 5, 4]
//        [1, 2, 3, 6, 5, 4]
//        [1, 2, 3, 4, 5, 6]
//        [1, 2, 3, 4, 5, 6]
//        [1, 2, 3, 4, 5, 6]
    }

    //选择排序
    public static void selectSort(int[] arr) {
        //遍历所有的数
        for (int i = 0; i < arr.length; i++) {
            int minIndex = i;
            //把当前遍历的数和后面所有的数依次进行比较，并记录最小的数的下标
            for (int j = i + 1; j < arr.length; j++) {
                //如果后面比较的数比记录的最小的数小
                if (arr[minIndex] > arr[j]) {
                    //记录最小的那个数的下标
                    minIndex = j;
                }
            }
            //如果发现了更小的元素，与第一个元素交换位置（第一个不是最小的元素）
            if (i != minIndex) {
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
            //打印每次排序后的结果
            System.out.println(Arrays.toString(arr));
        }
    }
}

时间复杂度

• 最优时间复杂度：O(n^2)
• 最坏时间复杂度：O(n^2)
• 稳定性：不稳定（考虑升序每次选择最大的情况）

选择排序与冒泡排序一样，需要进行N*(N-1)/2次比较，但是只需要N次交换，当N很大时，交换次数的时间影响力更大，所以选择排序的时间复杂度为O(N^2)。

虽然选择排序与冒泡排序在时间复杂度属于同一量级，但是毫无疑问选择排序的效率更高，因为它的交换操作次数更少，而且在交换操作比比较操作的时间级大得多时，选择排序的速度是相当快的。

代码改进

传统的选择排序每次只确定最小值，根据改进冒泡算法的经验，我们可以对排序算法进行如下改进：每趟排序确定两个最值——最大值与最小值，这样就可以将排序趟数缩减一半

改进后代码如下：

import java.util.Arrays;

public class seletsort {
    public static void main(String[] args) {
        int[] arr = {4, 5, 6, 3, 2, 1};
        selectSort(arr);
//        [1, 5, 4, 3, 2, 6]
//        [1, 2, 4, 3, 5, 6]
//        [1, 2, 3, 4, 5, 6]

    }

    //选择排序改进
    public static void selectSort(int[] arr) {
        int minIndex; // 存储最小元素的小标
        int maxIndex; // 存储最大元素的小标

        for (int i = 0; i < arr.length / 2; i++) {
            minIndex = i;
            maxIndex = i;
            //每完成一轮排序，就确定了两个最值，下一轮排序时比较范围减少两个元素
            for (int j = i + 1; j <= arr.length - 1 - i; j++) {
                //如果待排数组中的某个元素比当前元素小，minIndex指向该元素的下标
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                    continue;
                }
                //如果待排数组中的某个元素比当前元素大，maxIndex指向该元素的下标
                else if (arr[j] > arr[maxIndex]) {
                    maxIndex = j;
                }
            }

            //如果发现了更小的元素，与第一个元素交换位置（第一个不是最小的元素）
            if (i != minIndex) {
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;

                // 原来的第一个元素已经与下标为minIndex的元素交换了位置
                // 所以现在arr[minIndex]存放的才是之前第一个元素中的数据
                // 如果之前maxIndex指向的是第一个元素，那么需要将maxIndex重新指向arr[minIndex]
                if (maxIndex == i) {
                    maxIndex = minIndex;
                }
            }

            // 如果发现了更大的元素，与最后一个元素交换位置
            if (arr.length - 1 - i != maxIndex) {
                int temp = arr[arr.length - 1 - i];
                arr[arr.length - 1 - i] = arr[maxIndex];
                arr[maxIndex] = temp;
            }
            System.out.println(Arrays.toString(arr));
        }
    }
}