排序算法——选择排序plus

选择排序

时间复杂度：O(n^2)
最坏时间复杂度 O(n^2)
最好时间复杂度 O(n^2)
不稳定

由于后面的算法都有的功能，我将此抽取出来作为公共的方法了，有打印数组和交换数组的两个值
基本代码如下：

package cn.xiaov;

public class Common {
    //数组值交换
    public static void swap(int[] arr ,int i ,int j ){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    //打印数组
    public static void print(int[] arr){
        for (int o :arr) {
            System.out.print(o + " ");
        }
        System.out.println();
    }
}

常见的选择排序的算法代码：

private static void sort2(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
          int minPos = i;
          for (int j = i + 1; j < arr.length; j++) {
              minPos = arr[minPos] > arr[j] ? j : minPos;
          }
          Common.swap(arr, i, minPos);
          System.out.print("选择排序：第" + (i + 1) + "轮之后，数组的顺序：");
          Common.print(arr);
    }
}

示例数组：int[] arr = {8,6,4,1,5,7,9,2,3};
运行结果：

选择排序：第1轮之后，数组的顺序：1 6 4 8 5 7 9 2 3 
选择排序：第2轮之后，数组的顺序：1 2 4 8 5 7 9 6 3 
选择排序：第3轮之后，数组的顺序：1 2 3 8 5 7 9 6 4 
选择排序：第4轮之后，数组的顺序：1 2 3 4 5 7 9 6 8 
选择排序：第5轮之后，数组的顺序：1 2 3 4 5 7 9 6 8 
选择排序：第6轮之后，数组的顺序：1 2 3 4 5 6 9 7 8 
选择排序：第7轮之后，数组的顺序：1 2 3 4 5 6 7 9 8 
选择排序：第8轮之后，数组的顺序：1 2 3 4 5 6 7 8 9 

选择排序改进

改进思路：对比原算法构造一个指针，改进后构造两个指针，minPos和maxPos，分别找出最大值和最小值位置，时间缩短为一半

private static void sort2(int[] arr) {
    for (int i = 0; i < arr.length / 2 ; i++) {
         int minPos = i;
         int maxPos = arr.length - 1 - i;
         for (int j = i; j < arr.length - i; j++) {
             minPos = arr[j] > arr[minPos] ? minPos : j;
             maxPos = arr[j] > arr[maxPos] ? j : maxPos;
         }
         swap(arr, i, minPos);
         maxPos = i == maxPos ? minPos : maxPos;
         swap(arr, arr.length - 1 - i, maxPos);
         System.out.print("选择排序增强后：第" + (i + 1) + "轮之后，数组的顺序：");
         print(arr);
     }
 }

运行结果：

选择排序增强后：第1轮之后，数组的顺序：1 6 4 8 5 7 3 2 9 
选择排序增强后：第2轮之后，数组的顺序：1 2 4 6 5 7 3 8 9 
选择排序增强后：第3轮之后，数组的顺序：1 2 3 6 5 4 7 8 9 
选择排序增强后：第4轮之后，数组的顺序：1 2 3 4 5 6 7 8 9