java实现选择排序(推导、优化)

package com.bigdata.datastructure.sort;

import java.util.Arrays;

/**
 * 选择排序原理：(升序)
 *      一轮比较中，先假设第一个位置的为最小，确定最小值min和最小值对应的下标minIndex；
 *      然后依次和剩下的数进行比较，如果假设的最小值大于比较的数，则将最小值重置为该数，最小值所对应的下标重置为该数所对应的下标
 *      一轮比较完成后，将最小值和初始假定的值进行交换
 * @ description: 选择排序(推导优化)
 * @ author: spencer
 * @ date: 2020/11/4 16:08
 */
public class SelectSort {
    public static void main(String[] args) {

        int[] arr = {101, 34, 119, 1};
        selectSort(arr);
    }

    // 使用逐步推导的方式来解析选择排序
    private static void selectSort(int[] arr) {

        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]; // 这里没有进行交换，只是在重置最小值
                    minIndex = j; // 这里没有进行交换，只是在重置最小值所对应的下标
                }
            }

            // 循环完成后，找到最小值和最小值所对应的下标
            // 进行交换
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = min;
            }

            System.out.println("第" + (i + 1) + "轮后：" + Arrays.toString(arr));
        }

 /*     // 演化规律
        // 第一轮排序: 假定第一个就是最小值
        int minIndex = 0;
        int min = arr[0];
        for (int j = 0 + 1; j < arr.length; j++) {
            if (min > arr[j]) {
                min = arr[j]; // 这里没有进行交换，只是在重置最小值
                minIndex = j; // 这里没有进行交换，只是在重置最小值所对应的下标
            }
        }

        // 第一轮循环完成后，找到最小值和最小值所对应的下标
        // 进行交换，将最小值放在minIndex=0的位置
        if (minIndex != 0) {
            arr[minIndex] = arr[0];
            arr[0] = min;
        }

        System.out.println("第一轮后：" + Arrays.toString(arr));

        // 第二轮排序: 假定第一个就是最小值
        minIndex = 1;
        min = arr[1];
        for (int j = 1 + 1; j < arr.length; j++) {
            if (min > arr[j]) {
                min = arr[j]; // 这里没有进行交换，只是在重置最小值
                minIndex = j; // 这里没有进行交换，只是在重置最小值所对应的下标
            }
        }

        // 第一轮循环完成后，找到最小值和最小值所对应的下标
        // 进行交换，将最小值放在minIndex=0的位置
        if (minIndex != 1){
            arr[minIndex] = arr[1];
            arr[1] = min;
        }

        System.out.println("第二轮后：" + Arrays.toString(arr));

        // 第三轮排序: 假定第一个就是最小值
        minIndex = 2;
        min = arr[2];
        for (int j = 1 + 1; j < arr.length; j++) {
            if (min > arr[j]) {
                min = arr[j]; // 这里没有进行交换，只是在重置最小值
                minIndex = j; // 这里没有进行交换，只是在重置最小值所对应的下标
            }
        }

        // 第三轮循环完成后，找到最小值和最小值所对应的下标
        // 进行交换，将最小值放在minIndex=0的位置
        if (minIndex != 2){
            arr[minIndex] = arr[2];
            arr[2] = min;
        }

        System.out.println("第三轮后：" + Arrays.toString(arr));*/
    }
}