【排序算法】史上最通俗易懂的【选择排序】详解

1、按套路，先来一通基本思想：

    从待排序的n个数据中，每一趟在n-i+1个元素中选择值最小的元素作为有序序列中的第i个元素，从而达到排序的目的。

    简单说就是：第一趟：在n个元素中选择最小的元素与待排序数列的第一个元素交换

                         第二趟：在第2~n个元素中选择最小的元素与待排序数列的第二个元素交换

                         第三趟：在第3~n个元素中选择最小的元素与待排序数列的第三个元素交换

                         ……

 

2、以【96, 83, 27, 38, 11】这组待排序的数列为例：

   

    小结：

      1、可以发现n个元素共需要进行n-1趟排序就可完成，因为前n-1个元素确定好位置之后，最后一个自然而然就确定好了位置

      2、当选择出了最小的元素之后，若发现其就已经处于将要放置的位置时，则可以不用交换

 

3、分趟代码实现：

        
        //待排序数组
        int[] arr = {96, 83, 27, 38, 11};

        //记录最小元素
        int min;
        //记录最小元素的下标
        int index;

        /*
         *=============第一趟排序===============
         * 从第1个 ~ 第5个元素中选出最小的进行交换
         */

        //假设第1个元素是最小的
        min = arr[0];
        index = 0;
        //从第2个元素开始遍历
        for (int j = 1; j < arr.length; j++) {

            //如果发现第2个元素至第5个元素之间有比min还要小的元素
            if (arr[j] < min) {
                //更新最小的元素值
                min = arr[j];
                //更新最小元素的位置下标
                index = j;
            }

        }

        //开始交换，将最小的元素放置到第1个位置
        arr[index] = arr[0];
        arr[0] = min;



        /*
         *===============第二趟排序=================
         * 从第2个 ~ 第5个元素中选出最小的进行交换（因为第一个元素已经确定了）
         */

        //假设第2个元素是最小的
        min = arr[1];
        index = 1;
        //从第3个元素开始遍历
        for (int j = 2; j < arr.length; j++) {

            //如果发现第3个元素至第5个元素之间有比min还要小的元素
            if (arr[j] < min) {
                //更新最小的元素值
                min = arr[j];
                //更新最小元素的位置下标
                index = j;
            }

        }

        //开始交换，将最小的元素放置到第2个位置
        arr[index] = arr[1];
        arr[1] = min;



        /*
         *===============第三趟排序=================
         * 从第3个 ~ 第5个元素中选出最小的进行交换（因为第1，2个元素已经确定了）
         */

        //假设第3个元素是最小的
        min = arr[2];
        index = 2;
        //从第4个元素开始遍历
        for (int j = 3; j < arr.length; j++) {

            //如果发现第4个元素至第5个元素之间有比min还要小的元素
            if (arr[j] < min) {
                //更新最小的元素值
                min = arr[j];
                //更新最小元素的位置下标
                index = j;
            }

        }

        //开始交换，将最小的元素放置到第3个位置
        arr[index] = arr[2];
        arr[2] = min;



        /*
         *===============第四趟排序=================
         * 从第4个 ~ 第5个元素中选出最小的进行交换（因为第1,2,3个元素已经确定了）
         */

        //假设第4个元素是最小的
        min = arr[3];
        index = 3;

        for (int j = 4; j < arr.length; j++) {

            if (arr[j] < min) {
                min = arr[j];
                index = j;
            }
        }

        //交换
        arr[index] = arr[3];
        arr[3] = min;

 

通过上边的分趟代码，我们可以使用循环一步到位，代码如下：

        //每次从当前位置到最后位置之间选择出最小的元素，放到当前的位置
        for (int i = 0; i < arr.length - 1; i++) {
            min = arr[i];
            index = i;
            for (int j = i; j < arr.length; j++) {

                if (arr[j] < min) {
                    min = arr[j];
                    index = j;
                }
            }

            //交换
            arr[index] = arr[i];
            arr[i] = min;
            
        }

 

4、优化

        在上边的小结中我们指出了，当选择出了最小的元素之后，若发现其就已经处于将要放置的位置时，则可以不用交换，因此代码优化如下：

        
        //每次从当前位置到最后位置之间选择出最小的元素，放到当前的位置
        for (int i = 0; i < arr.length - 1; i++) {
            min = arr[i];
            index = i;
            for (int j = i; j < arr.length; j++) {

                if (arr[j] < min) {
                    min = arr[j];
                    index = j;
                }

            }

            //交换
            //如果要交换的就是当前的元素，则不用交换
            if (index != i) {
                arr[index] = arr[i];
                arr[i] = min;
            }

 

 

 欧了，代码中注释部分解释的应该挺详细的了，我是小K，勇敢做自己，做最好的自己=。=