Java排序算法——选择排序（Selection Sort）

上次总结了一下冒泡排序，这次来看看同样非常简单的选择排序

上期冒泡排序传送门：

Java排序算法——冒泡排序（Bubble Sort）https://blog.csdn.net/babbfqb93/article/details/123005968?spm=1001.2014.3001.5501

选择排序（Selection Sort）就是通过选择一个数组中的最大（小）值排序到数组的头部位置（和头部位置交换）接下来循环剩余数组找到次最大（小）值排序到第二的位置，以此类推，直到所有的数字都被选择完成之后完成排序。整体效果如下图：

上图是全部的一个过程，总体的来说，为了方便理解，我们解析一下过程。 

首先还是看一下内层的第一次循环：

图片如下：

可以看到，第一次循环确定所有数组中的最小值为14，所以将14于第一个位置的20进行交换，我们把实现的代码逻辑展示一下：

在展示初始化逻辑之前，我们先需要对于数组的初始化和数组元素交换方法做一个简单的封装：

 首先是初始化数组的逻辑：

//初始换一个长度为参数的随机数组，数组元素为0（含）到50（不含）的随机数
public static int[] initArray(int length){
    Random r = new Random();//申明并实例化一个Random对象
    int[] iArray = new int[length];//申明并实例化一个int数组用于测试排序
    for (int i = 0; i < iArray.length; i++) {
        //通过Random随机生成一个0（含）到50（不含）的数并插入对应位置
        iArray[i] = r.nextInt(50);
    }
    return iArray;
}

接下来是下面是交换2个下标位置元素的方法：

//交换传递数组下表的i与j元素的交换
public static void swap(int[] iArray,int i,int j){
    int tmp = iArray[i];
    iArray[i] = iArray[j];
    iArray[j] = tmp;
}

好了，有了这两个方法，我们就可以安心实现选择排序了，先是通过第一层逻辑，将逻辑代码写出来：

//选择排序
public static void selectionSort(int[] iArray) {
    //若传递的数组为空，或者长度1则直接返回
    if (iArray == null || iArray.length < 2) {
        return;
    }
    //这个值用来当前循环获取到的最小值的一个下标数
    int minIndex = 0;
    //循环整体的数组，比较找到最小元素的下标
    for (int i = 0; i < iArray.length - 1; i++) {
        //若当前元素比存储下标的元素小，则存储当前下标
        if (iArray[i] < iArray[minIndex]) {
            //存储当前下标
            minIndex = i;
        }
    }
    //将首位数与最小数交换
    swap(iArray, 0, minIndex);
}

以上为第一层循环的逻辑，也可以理解为内层循环的逻辑，接下来我们需要的便利整个数组，将每个位置都确定为剩余数组元素的最小值，我们也和冒泡排序一样，使用嵌套for循环的方式实现，

 每个框对应的都是一层外部循环，所以可以看出是从0开始，循环次数为总体数组长度-1，我们在写外层的同时，将内层逻辑修改，内层的起点我们之前最开始是从0开始，现在我们应该是从外层循环的循环次数+1开始（因为我们可以把外层循环次数设置为默认的最小值，还是用代码来写比较清楚一些（代码中有注释））

//选择排序
public static void selectionSort(int[] iArray) {
    //若传递的数组为空，或者长度1则直接返回
    if (iArray == null || iArray.length < 2) {
        return;
    }
    for(int i = 0 ;i<iArray.length-1;i++){
        //从外层循环次数设置为初始值，这样可以减少一次内层循环
        int minIndex = i;//存储当前循环获取到的最小值的一个下标数
        //循环整体的数组，比较找到最小元素的下标
        //起点为外层循环+1，因为每一次外层循环都确定第i个下标为当前最小值
        for (int j = i+1; j < iArray.length; j++) {
            //若当前元素比存储下标的元素小，则存储当前下标
            if (iArray[j] < iArray[minIndex]) {
                //存储当前下标
                minIndex = j;
            }
        }
        //若下标为最小值，则不交换
        if(i!=minIndex) {
            //将当前循环的下标位置数与最小数交换
            swap(iArray, i, minIndex);
        }
    }
}

以上便是封装好的一套选择排序了，我们可以写一个测试入口：

public static void main(String[] args) {
    //初始化数组
    int[] iArray = initArray(7);
    //输出排序前结果
    System.out.println("------排序之前------");
    System.out.println(Arrays.toString(iArray));
    System.out.println("-------------------");
    //排序...
    System.out.println("------正在排序------");
    selectionSort(iArray);
    System.out.println("-------------------");
    //输出排序后结果
    System.out.println("------排序之后------");
    System.out.println(Arrays.toString(iArray));
    System.out.println("-------------------");
}

可以看到运行之后达到预期了。

引用一下个人查询到的相关gif，帮助大家总结一下（我实在找不到gif的作者，这个图用于学习真的很棒！感谢gif图作者）

 好，我说完了。记得关注，点赞，我会在之后更新更多内容......