选择排序优化之二元选择排序/干货满满

优化选择排序分治

会基本的插入排序,想要进行优化的看这篇文章.

一.定义排序接口

public interface ISort {

	 /**
     * 排序方法
     */
    void sort(int[] arr);

    /**
     * 获取测试数据
     */
    default int[] getTestData() {
        int[] arr = new int[20];
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(1000);
        }
        return arr;
    }

    /**
     * 数组根据索引换位
     */
    default void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

}

二.定义对数器

/**
 * @Author owen
 * @Date 2021/8/10 9:18
 * @Description 对数器 用于测试排序算法是的正确性
 **/
public class Detector {
    private static final String SUCCESS = "成功";
    private static final String FAILURE = "失败";
    
    /**
     * @param sortObj 排序的实现
     * @param count   测试次数
     * @return 是否对数成功
     */
    public String isRight(ISort sortObj, int count) {
        //if (Objects.isNull(sortObj)) sortObj = new SelectionSort();
        if (count <= 0) count = 1;
        boolean flag = true;
        long startTime = System.currentTimeMillis();
        for (int c = 0; c < count; c++) {
            int[] ori = sortObj.getTestData();
            int[] dest = Arrays.copyOf(ori, ori.length);
            Arrays.sort(ori);
            sortObj.sort(dest);
            //对比ori和dest排序后是否一样
            for (int i = 0; i < ori.length; i++) {
                if (ori[i] != dest[i]) {
                    flag = false;
                    break;
                }
            }
        }
        long endTime = System.currentTimeMillis();
        long useTime = endTime - startTime;
        System.out.println("排序 " + count + " 次用时 " + useTime + " 毫秒");
        return flag ? SUCCESS : FAILURE;
    }
}

三.编写二元选择排序算法

/**
 * @Author owen
 * @Date 2021/8/10 15:09
 * @Description 二元选择排序
 **/
public class TwoSelectionSort implements ISort {

    @Override
    public void sort(int[] arr) {
        int len = arr.length;
        for (int j = 0; j < len / 2; j++) {    // 一次循环找出最大和最小值 ,最大放最后,最小放最前.所以是循环len/2次
            int min, max;
            min = max = j;                     //定义min 和 max 索引位置 都是从0开始扫描.
            for (int i = j + 1; i < len - j; i++) {     //使用min和max索引上的数  比较 j+1 之后和 len-j 之间的数
                if (arr[min] > arr[i]) {
                    min = i;
                    continue;
                }
                max = arr[max] < arr[i] ? i : max; // trick 诡计(三什么表达式)
            }
			//new int[]{9, 5, 2, 6, 7, 1, 8, 4} 如果第一个数是最大值,那么最小值放到第一位后,最大值的数就换到最小值的位置了.所以进行判断.
            if (max == j) {             
                max = min;
            }
            swap(arr, min, j);              //交换最小值和当前外循环的数的位置.
            swap(arr, max, len - j - 1);  //交换最大值到外循环的length-循环次数-1的位置上.
        }
    }
}

四.编写测试类

/**
 * @Author owen
 * @Date 2021/8/10 8:51
 * @Description 测试类
 **/
public class Test {
    public static void main(String[] args) {
        ISort sort = new TwoSelectionSort();
        //第一个参数是排序的实现类 第二个参数是测试多少次(每次数据不同).
        String res = new Detector().isRight(sort, 1000000);
        System.out.println("测试结果: "+res);
    }
}

测试后发现二元选择排序 没有普通的选择排序效率高.但是也差不了太多
在1000000次的测试下,普通插排 900 -1000毫秒之间的处理速度.二元排序在1000-1200毫秒之间的处理速度.