基础排序算法之选择排序法

一、选择排序法思路：先将最小（大）的元素取出，再在剩下的元素，再将其中最小（大）的取出，每次选择未处理的元素中最小（大）的元素，进行排序。

    1、两种思路：

          ①开辟一个新的数组空间，将比较出来的最小（大）元素依次放入新数组中进行排序

          ②进行原地排序，在源数组中进行元素的交换。

二、算法的实现

    1、开辟空间排序算法实现：

    /**
     * 开辟空间异地排序
     * 对一个数组的元素进行排序（从小到大输出）,选择排序
     */
    public static void sortArray2(int[] array){
        /*
        newArray//作为存放新排序后的数组的元素。
         */
        int[] newArray=new int[array.length];//定义一个新数组（新空间）
        for (int i=0;i<array.length;i++){
            int minIndex=i;
            for (int j=i;j<array.length;j++){
                if (array[j]<array[minIndex]){
                    minIndex=j;
                }
                newArray[i]=array[minIndex];
            }
            array[minIndex]=array[i];//不能重复让最小的元素进行循环，应该将其覆盖掉。
        }
        System.out.println(Arrays.toString(newArray));
    }

如此排序思路简单，但是造成了空间上的浪费，于是我们需要优化选择排序。

    2、原地排序思路如下图：

            

       解析：将i索引定为循环开始，i为外层循环，循环开始后，将最小值索引设置为minIndex，并且暂定为索引i的元素，然后从j开始往后检索，此时j=i，若j索引位置的元素小于minIndex索引位置的元素，则将最小值索引minIndex替换为当前的j；当内层循环走过一遍后，即可得到整个数组（因为此时是第一遍循环）的最小值，每次循环都可在[i，array.length)范围内找到其中的最小值。然后将得到的最小值便可将其与当前外层循环的i元素进行交换，如此即可完成原地排序。

    注意事项：元素交换的常用模式：定义一个swap作为中间变量进行交换。

3、算法实现：

 /**
     * 原地排序
     * 对一个数组的元素进行排序（从小到大输出）,选择排序
     */
    public static void sortArray1(int[] array) {
        /*int i = array[0];//取出第一个元素，逐个与数组中其他元素进行比较，大于则替换，否则不变。
        int j;//记录所需要进行比较扫描的数组元素索引，对arr[j,arr.length-1]进行扫描。
        int minIndex = 0;//记录比较后，替换的元素的索引
        int swap=0;作为交换中间变量(固定模式)*/
        for (int i = 0; i < array.length; i++) {
            int minIndex=i;
            for (int j=i;j<array.length;j++){
                if (array[j]<array[minIndex]){
                    minIndex=j;
                }
            }
            //进行交换
            int swap=array[i];
            array[i]=array[minIndex];
            array[minIndex]=swap;
        }
       for (int k=0;k<array.length;k++){
           System.out.println(array[k]);
       }
    }

   4、作为一个方法，应当符合方法的复用性，所以这里应当将方法泛型化，如下：

/**
     * 优化选择排序原地排序，让算法的复用性提高----即泛型化。
     * 泛型方法：在修饰符后面加<E>,extends Comparable的作用是限制参数为可比较的（只接收继承类及其子类的类型）。
     *         ** 若为super，则参数只接收该类及其父类。
     */
    public static <E extends Comparable<E>> void selectSort(E[] array){
        for (int i=0;i<array.length;i++){
            int minIndex=i;
            for (int j=i;j<array.length;j++){
                if (array[j].compareTo(array[minIndex])<0){//comparableTo方法相当于减法顺序，结果大于零则前者大于后者；
                                                           //反之则小于，两者相等则等于零。
                    minIndex=j;
                }
                //交换元素位置，实现排序
                E swap=array[i];
                array[i]=array[minIndex];
                array[minIndex]=swap;
            }
        }
        System.out.println(Arrays.toString(array));
    }

以上方法，对于测试时，数组应当为可比较的数据类型，而且不能为基本数据类型，应为其包装类。应为泛型不能是基本数据类型。

三、对算法复杂度浅析

     由以上的算法实现可以看出：其实程序的进行，被检索的元素是逐渐减少的，类似

 1+2+3+4+...+n的等差数列，于是，我们可以列出其复杂度的公式:1/2n^2+1/2n。又因为在算法复杂度分析中，常数级别的复杂度可以忽略，即n平方前的系数二分之一，然后n比n方低阶，当数据达到一定规模时，也是忽略的，所以该算法的复杂度为O(n^2)。