选择排序

一种内部排序，选出某个元素，按照规则交换

基本思想：

重复（元素个数-1）次

  把第一个没有排序过的元素设置为最小值

  遍历每个没有排序过的元素

    如果元素 < 现在的最小值

      将此元素设置成为新的最小值

  将最小值和第一个没有排序过的位置交换

 

 

第一次：遍历数组，找到最小值后，与arr[0]交换
第二次：从arr[1] - arr[n-1]中选择最小的，与arr[1]交换。
.
.
.
.
第i次：从arr[i-1]-arr[n-1]中选择最小值，与arr[i-1]交换

实例：原始的数组：101， 34， 119， 1
第一轮排序：1,34,119,101
第二轮排序：1,34,119,101
第三轮排序：1,34,101,119
说明：
1）选择排序一个有数组大小-1轮排序
2）每一轮排序，又是一个有规则的循环
2.1）先假定当前这个数是最小的，
2.2）然后和后面每个数进行比较，如果发现有比它更小的，就重新确定最小数，并得到下标
2.3）当遍历到数组的最后时，就得到本轮最小数和小标
2.4）交换

代码：

// 选择排序 时间复杂度为O（n^2),,嵌套for循环
    public  static void selectSort(int[] arr) {

        // 使用逐步推导的方式
        // 第一轮
        // 原始的数组：101， 34， 119， 1
        // 第一轮排序：1,34,119,101
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            int min = arr[i];
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]) { // 说明假定的最小值不是最小
                    min = arr[j]; // 重置min
                    minIndex = j; // 重置minIndex
                }
            }
            // 将最小值，放在arr[0],即交换
            if (minIndex != i) { // 优化部分
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
            System.out.println("第"+(i + 1)+"轮后");
            System.out.println(Arrays.toString(arr));
        }



//        // 第二轮排序：1,34,119,101
//         minIndex = 1;
//         min = arr[1];
//        for(int j = 1 + 1; j < arr.length; j++) {
//            if(min > arr[j]) { // 说明假定的最小值不是最小
//                min = arr[j]; // 重置min
//                minIndex = j; // 重置minIndex
//            }
//        }
//        // 将最小值，放在arr[0],即交换
//        if(minIndex != 1) {
//            arr[minIndex] = arr[1];
//            arr[1] = min;
//        }
//
//        System.out.println("第2轮后");
//        System.out.println(Arrays.toString(arr));
//
//
//
//        // 第三轮排序：1,34,101,119
//        minIndex = 2;
//        min = arr[2];
//        for(int j = 2 + 1; j < arr.length; j++) {
//            if(min > arr[j]) { // 说明假定的最小值不是最小
//                min = arr[j]; // 重置min
//                minIndex = j; // 重置minIndex
//            }
//        }
//        // 将最小值，放在arr[0],即交换
//        if(minIndex != 2) {
//            arr[minIndex] = arr[2];
//            arr[2] = min;
//        }
//        System.out.println("第3轮后");
//        System.out.println(Arrays.toString(arr));
//

    }