选择排序-简单选择排序

返回目录

基本思想

第一次从 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 次，得到一个按排序码从小到大排列的有序序列。——尚硅谷

简单来说：每次都从未排序的数组中选取最小的值，然后将该值与未排序的数组中的第一个值进行交换。

动画演示

插入排序示例

Java代码：

package sort;

import java.util.Random;
import java.util.Scanner;

public class SelectSort {
    public static void main(String[] args) {
        int num, min, max;//数组个数，最小值，最大值
        int direction;
        int[] arr;//数组
        Scanner scanner = new Scanner(System.in);
        System.out.printf("请输入要随机生成数组的个数：");
        num = scanner.nextInt();
        System.out.printf("请输入要随机生成数组的最小值：");
        min = scanner.nextInt();
        System.out.printf("请输入要随机生成数组的最大值：");
        max = scanner.nextInt();
        arr = randomArrays(num,min,max);//生成数组
        System.out.printf("生成的数组：");
        traversalOutput(arr);
        selectSorting(arr);//选择排序
    }
    /**
     * 随机生成数组函数
     * @param num 数组个数
     * @param min 数组值最小值
     * @param max 数组值最大值
     * @return
     */
    public static int[] randomArrays (int num, int min, int max){
        Random rd = new Random();
        int[] arr = rd.ints(num, min, max + 1).toArray();
        return arr;
    }

    /**
     * 数组遍历输出
     * @param arr 数组
     */
    public static void traversalOutput (int[] arr){
        for (int i : arr) {
            System.out.printf("%d ", i);
        }
        System.out.println("");
    }

    /**
     * 元素进行交换操作
     * @param arr 数组
     * @param minIndex 当前最小值下标
     * @param min 当前最小值
     * @param i 存放当前最小值的位置的下标
     */
    public static void exchange (int[] arr, int minIndex, int min, int i){
        arr[minIndex] = arr[i];
        arr[i] = min;
    }

    /**
     * 选择交换
     * @param arr
     */
    public static void selectSorting(int[] arr){
        int minIndex, min;
        for (int i = 0; i < arr.length -1; i++) {
            minIndex = i;//最小值的下标
            min = arr[minIndex];//最小值
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]){
                    minIndex = j;
                    min = arr[minIndex];
                }
            }
            if (minIndex != i){
                exchange(arr,minIndex,min,i);
            }
            System.out.printf("第%d次交换后的数组：",i+1);
            traversalOutput(arr);
        }
    }
}

代码分析

 /**
 * 选择交换排序
 * @param arr
 */
public static void selectSorting(int[] arr){
    int minIndex, min;
    for (int i = 0; i < arr.length -1; i++) {
        minIndex = i;//最小值的下标
        min = arr[minIndex];//最小值
        for (int j = i + 1; j < arr.length; j++) {
            if (min > arr[j]){
                minIndex = j;
                min = arr[minIndex];
            }
        }
        exchange(arr,minIndex,i);
        System.out.printf("第%d次交换后的数组：",i+1);
        traversalOutput(arr);
    }
}

外层循环决定比较次数，内层循环决定比较的元素要从哪个位置开始。
假定未排序中的第一个元素（其实只要是未排序的元素中的任何一个元素都可以）是最小的元素。定义两个变量，一个存储该元素值，一个存储该元素的下标。
这个假定的元素与所有剩余的未排序的元素进行比较，如果有元素比它更小说明它不是最小的元素，那么将最小值的下标与最小值该定为目前的这个元素的下标与值。
当完成该轮循环时就能够确定当前最小的元素的位置。
在外层循环中进行交换。
时间复杂度：此O(n2)（双循环）。
空间复杂度：o(1)，。
算法稳定性：稳定。

优化

当第一选择的最小值就是未排序元素中的最小值，在外层循环的交换操作是没有意义的。
java代码：

package sort;

import java.util.Random;
import java.util.Scanner;

public class SelectSort {
    public static void main(String[] args) {
        int num, min, max;//数组个数，最小值，最大值
        int direction;
        int[] arr;//数组
        Scanner scanner = new Scanner(System.in);
        System.out.printf("请输入要随机生成数组的个数：");
        num = scanner.nextInt();
        System.out.printf("请输入要随机生成数组的最小值：");
        min = scanner.nextInt();
        System.out.printf("请输入要随机生成数组的最大值：");
        max = scanner.nextInt();
        arr = randomArrays(num,min,max);//生成数组
        System.out.printf("生成的数组：");
        traversalOutput(arr);
        selectSorting(arr);//选择排序
    }
    /**
     * 随机生成数组函数
     * @param num 数组个数
     * @param min 数组值最小值
     * @param max 数组值最大值
     * @return
     */
    public static int[] randomArrays (int num, int min, int max){
        Random rd = new Random();
        int[] arr = rd.ints(num, min, max + 1).toArray();
        return arr;
    }

    /**
     * 数组遍历输出
     * @param arr 数组
     */
    public static void traversalOutput (int[] arr){
        for (int i : arr) {
            System.out.printf("%d ", i);
        }
        System.out.println("");
    }

    /**
     * 元素进行交换操作
     * @param arr 数组
     * @param minIndex 当前最小值下标
     * @param min 当前最小值
     * @param i 存放当前最小值的位置的下标
     */
    public static void exchange (int[] arr, int minIndex, int min, int i){
        arr[minIndex] = arr[i];
        arr[i] = min;
    }

    /**
     * 选择交换
     * @param arr
     */
    public static void selectSorting(int[] arr){
        int minIndex, min;
        for (int i = 0; i < arr.length -1; i++) {
            minIndex = i;//最小值的下标
            min = arr[minIndex];//最小值
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]){
                    minIndex = j;
                    min = arr[minIndex];
                }
            }
            if (minIndex != i){
                exchange(arr,minIndex,min,i);
            }
            System.out.printf("第%d次交换后的数组：",i+1);
            traversalOutput(arr);
        }
    }
}

优化代码：
在元素进行交换时多增加一个判断语句：

if (minIndex != i){

}