选择排序

选择排序原理（此处由从小到大排序）
----给定一个待排序的数组，遍历该数组元素，并设置两个变量（min和minIndex）来记录当前遍历过程中的最小值以及其索引。
这两个变量初始化为数组的第0个元素，遍历可以直接从下标为1的元素开始遍历。再遍历过程中如果出现了
比记录值还要小的值，则将该值的数值和索引分别赋值给记录最小值以及索引的两个变量。
----每一轮遍历结束都会得出一个遍历范围内的数组元素的最小值，将该值与变量min与minIndex的交换；
下一轮遍历的两个变量初始化的位置则是上一轮索引位置加1。
定义一个长度为4的数组如下：int[] arr2 = {3, -1, 4, 5};
选择排序的过程如下：

点击查看代码

private static void sortBySelect(int[] arr) {
        //第一轮排序
        for (int i = 1; i < arr.length; i++) {
            int minIndex=0;//最小值索引
            int min = arr[0];//最小值
            if (min > arr[i]) {
                minIndex=i;
                min = arr[i];
            }
            //交换位置
            arr[minIndex]=arr[0];//把第一个元素赋值给最小的元素的索引位置上的值
            arr[0]=min;//把最小的值赋值给0索引位置
        }
        System.out.println("第一轮排序的结果arr："+ Arrays.toString(arr));
        //第二轮排序
        for (int i = 2; i < arr.length; i++) {
            int minIndex=1;//最小值索引
            int min = arr[1];//最小值
            if (min > arr[i]) {
                minIndex=i;
                min = arr[i];
            }
            //交换位置
            arr[minIndex]=arr[1];//把第一个元素赋值给最小的元素的索引位置上的值
            arr[1]=min;//把最小的值赋值给0索引位置
        }
        System.out.println("第二轮排序的结果arr："+ Arrays.toString(arr));
        //第三轮排序
        for (int i = 3; i < arr.length; i++) {
            int minIndex=2;//最小值索引
            int min = arr[2];//最小值
            if (min > arr[i]) {
                minIndex=i;
                min = arr[i];
            }
            //交换位置
            arr[minIndex]=arr[2];//把第一个元素赋值给最小的元素的索引位置上的值
            arr[2]=min;//把最小的值赋值给0索引位置
        }
        System.out.println("第三轮排序的结果arr："+ Arrays.toString(arr));

    }

其结果如下： `第一轮排序的结果arr：[-1, 3, 4, 5]` `第二轮排序的结果arr：[-1, 3, 4, 5]` `第三轮排序的结果arr：[-1, 3, 4, 5]` 可以看出一个长度为4的数组，只需要遍历3轮即可； 接下来使用两层嵌套for循环来改进：

点击查看代码

private static void sortBySelectTwo(int[] arr) {
        for (int n = 0; n < arr.length - 1; n++) {
            for (int i = n + 1; i < arr.length; i++) {
                int minIndex=n;
                int min = arr[n];
                if (min > arr[i]) {
                    flag=false;
                    minIndex=i;
                    min = arr[i];
                }
                arr[minIndex] = arr[n];
                arr[n]=min;
            }
            System.out.println("第"+n+"轮排序的结果arr："+ Arrays.toString(arr));
        }
    }

与冒泡排序相似，此改进方法仍然存在部分情况是的排序过程中无元素交换位置，则可以跳出内层循环 继续执行下轮遍历。优化后的方法如下：

点击查看代码

    private static void sortBySelectTwo(int[] arr) {
        boolean flag=true;
        for (int n = 0; n < arr.length - 1; n++) {
            for (int i = n + 1; i < arr.length; i++) {
                int minIndex=n;
                int min = arr[n];
                if (min > arr[i]) {
                    flag=false;
                    minIndex=i;
                    min = arr[i];
                }
                arr[minIndex] = arr[n];
                arr[n]=min;
            }
            if (flag) {
                break;
            } else {
                flag=true;
            }
            System.out.println("第"+n+"轮排序的结果arr："+ Arrays.toString(arr));
        }
    }