排序算法 - 选择排序(Selection Sort)

选择排序(Selection Sort)

选择式排序也属于内部排序法， 是从欲排序的数据中， 按指定的规则选出某一元素， 再依规定交换位置后达到排序的目的。

选择排序的演变过程（从小到大）

• 第一次从 arr[0]~arr[n-1]中选取最小值，与 arr[0] 交换
• 第二次从 arr[1]~arr[n-1]中选取最小值， 与 arr[1] 交换
• 第三次从 arr[2]~arr[n-1]中选取最小值， 与 arr[2] 交换
• 第 i 次从 arr[i-1]~arr[n-1]中选取最小值， 与 arr[i-1] 交换
• 第 n-1 次从 arr[n-2]~arr[n-1]中选取最小值，与 arr[n-2] 交换
• 总共通过 n-1 次， 得到一个按排序码从小到大排列的有序序列

//选择排序
public class SelectSort {

	public static void main(String[] args) {
		int[] arr = { 101, 34, 119, 1 };
		selectSort(arr);
	}

	// 选择排序
	public static void selectSort(int[] arr) {
		// 使用逐步推导的方式来，讲解选择排序
		// 第1轮
		// 原始的数组 ： 101, 34, 119, 1
		// 第一轮排序 : 1, 34, 119, 101
		// 算法 先简单--》 做复杂， 就是可以把一个复杂的算法，
		// 拆分成简单的问题-》逐步解决

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

		// 第2轮
		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, 119, 101

		// 第3轮
		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));// 1, 34, 101, 119
	}

}
/*
第1轮后~~
[1, 34, 119, 101]
第2轮后~~
[1, 34, 119, 101]
第3轮后~~
[1, 34, 101, 119]
*/

选择排序实例代码

public class SelectionSortApp {
    public static int[] setArray(int capacity) {
        int[] arr = new int[capacity];
        for (int i =0; i < capacity;i++) {
            arr[i] = (int) (Math.random() * capacity);
        }
        return arr;
    }

    /** 选择排序方法
     * 时间复杂度为平方阶 O(n2)*/
    public static void selectionSort(int[] arr) {
        /** 假定的最小值*/
        int min = 0;
        /** 假定的最小值的元素下标*/
        int minIndex = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            min = arr[i];
            minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                /** 假定的最小值, 并不是最小*/
                if (min > arr[j]) {
                    /** 重置最小值和指定下标*/
                    min = arr[j];
                    minIndex = j;
                }
            }

            /** 内部 for循环的(j = i + 1)范围内, 再发生一次重新锁定的最小值的情况时*/
            if (minIndex != i) {
                /** 通过临时变量 min, 转移最小值的临时变量*/
                arr[minIndex] = arr[i];
                arr[i] = min;
            }

            System.out.println("i=" + i + ": " + Arrays.toString(arr));
        }
    }

    public static void main(String[] args) {
        int arr[] = {3, 9, 1, 10, 2};
        System.out.println("排序前 " + Arrays.toString(arr));
        /** 开始选择排序*/
        selectionSort(arr);
    }
}
/*
输出:
> 排序前 [3, 9, 1, 10, 2]
* 3>9=false	此次循环中, 3依然是最小值, 继续
* 3>1=true	将假定的最小值改成1设置, 继续
* 1>10=false	1依然是最小值, 继续
* 1>2=false	1依然是最小值. 此次有过交换, 
* 所以在 if (minIndex != i)中交换元素值
> i=0: [1, 9, 3, 10, 2]
* 9比较3
* 3比较10
* 3比较2
> i=1: [1, 2, 3, 10, 9]
* 3比较10
* 3比较9
> i=2: [1, 2, 3, 10, 9]
* 10比较9
> i=3: [1, 2, 3, 9, 10]
*/

选择排序效率（较低）

/** 生成长度为 100000的随机值数组, 用于与其它算法对比排序效率*/
int[] arr = setArray(100000);
System.out.println("开始时间 " + 
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(LocalDateTime.now()));
/** 开始选择排序*/
selectionSort(arr);
System.out.println("结束时间 " + 
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(LocalDateTime.now()));
/*
输出:
> 开始时间 2020-10-14 14:04:09
> 结束时间 2020-10-14 14:04:12
> */