超详解内部排序算法之（二）选择排序

选择排序

选择排序的思想

选择排序是一张简单的排序方法，基本思想：第一次从数组中【arr[0]~arr[n-1]】选取最小值，与arr[0]交换，第二次从【arr[1]-arr[n-1]】选取最小值与arr[1]进行交换，第三次从arr[2]-arr[n-1]选取最小值与arr[2]进行交换，…,第i次从arr[i]-arr[n-1]中选取最小值，与arr[i-1]进行交换，…，第n-1次从arr[n-2]-arr[n-1]中选取最小值，与arr[n-2]交换，总共交换n-1次，得到一个按排序码从小到大排列的有序序列。

选择排序思路分析

我们通过对于数组[12,4,9,112,-6,5]

我们用图来理解一下选择排序的过程
按照上边所讲的，我们先通过第一个元素和剩余元素依次比较，红色代表当前比较的最小值元素，绿色代表当前参与比较的元素，黄色为该插入元素的索引和数值。找到最小的元素并将其放置在索引为0的下标处。
依次找到第二小、第三小，。。。，第n-2小的元素放置在对应的位置。

代码实现

结论代码

public static void selectSorted(int[] array){
        for (int i = 0; i < array.length-1; i++) {
            int minIndex = i;
            int min = array[i];
            for (int j = i+1; j < array.length; j++) {
                //Set default value
                if(min > array[j]){
                    min=array[j];
                    minIndex = j;
                }
            }
            if(minIndex!=i){
                array[minIndex]=array[i];
                array[i]=min;
            }
           System.out.println("The "+(i+1)+" times circulation ");
           System.out.println(Arrays.toString(array));
        }
    }

分布代码详解

我们老规矩，按照我们分析的逻辑，从特殊到一般，自己推导出这个内部实现的规律，便于我们更好的理解，关键是这个思想，java代码实现只是我们的实现之一，也可以使用其他编程语言的。万变不离其宗，我们掌握这个一，就可以一生二，二生三，三生无穷尽了。哈哈

		//The First circulation  第一轮
        int minIndex = 0;
        int min=array[0];
        for (int j = 1; j < array.length; j++)  {
           if(min>array[j]){
               min=array[j];
               minIndex = j;

           }
        }
        array[0]=min;
        array[minIndex]=array[0];

        //The Second circulation 第二轮
        minIndex = 1;
        min=array[1];
        for (int j = 2; j < array.length; j++)  {
            if(min>array[j]){
                min=array[j];
                minIndex = j;

            }
        }
        array[1]=min;
        array[minIndex]=array[1];
        
		//The Thrid circulation 第三轮
        minIndex = 2;
        min=array[2];
        for (int j = 3; j < array.length; j++)  {
            if(min>array[j]){
                min=array[j];
                minIndex = j;

            }
        }
        array[2]=min;
        array[minIndex]=array[2];


		//The fourth circulation 第四轮
        minIndex = 3;
        min=array[3];
        for (int j = 4; j < array.length; j++)  {
            if(min>array[j]){
                min=array[j];
                minIndex = j;

            }
        }
        array[3]=min;
        array[minIndex]=array[3];


		//The fifth circulation 第五轮
        minIndex = 4;
        min=array[4];
        for (int j = 5; j < array.length; j++)  {
            if(min>array[j]){
                min=array[j];
                minIndex = j;

            }
        }
        array[4]=min;
        array[minIndex]=array[4];
        

通过对于上边的归纳，我们用一个for循环处理，每一次都是递增的基础上做一个同样的判断和处理
for (int i = 0; i < array.length-1; i++) {
int minIndex = i;
int min = array[i];
for (int j = i+1; j < array.length; j++) {
//Set default value
if(min > array[j]){
min=array[j];
minIndex = j;
}
}
array[minIndex]=array[i];
array[i]=min;
System.out.println("The “+(i+1)+” times circulation ");
System.out.println(Arrays.toString(array));
}
我们在中间打印出每一轮的结果，看看和我们最初的分析结果是否一致

结果

最终的结果和我们的分析是一致的，所以我们的代码实现是没有问题。
另外我们也来看看选择排序对于一定数据规模的处理时间是多少
我们直接上代码

public static void main(String[] args) {
       
        int[] array = new int[80000];
        for (int i = 0; i < array.length; i++) {
            array[i]=(int)(Math.random()*800000);
        }

        System.out.println("选择排序！");

        Date dateStart = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Front of Execute:"+simpleDateFormat.format(dateStart));
        
        selectSorted(array);
        
        Date dateEnd = new Date();
        System.out.println("Front of Execute:"+simpleDateFormat.format(dateEnd));

    }

我们选择80000个数据进行测试，大致需要的时间如下图

小伙伴们可以在自己的机器上操作尝试一下，我们重点在理解对应的思想，实现只是我们思想的一个体现。