优化选择排序

优化选择排序

选择排序的思想：第一次外层循环中找出数组中的最小值，放到数组最前端，接下来要遍历的长度就是[1,arr.length-1],(本身可遍历的是[0,arr.length-1])，第二次下来就是[2,arr.length-1]…

优化思想：在一次外层外层循环中找出最小值和最大值，将最小值放到数组开头，将最大值放到数组末尾，这样一次循环之后数组可遍历的长度是[1,arr.length-2],效率比起原来有所提升。

看优化后代码：

public class Selection {

    //优化选择排序,一次i循环找出最小值和最大值。
    public static void main(String[] args) {
        int arr[] = {5,3,2,1,4,7,9,8,6};
        int al = arr.length-1;
        for (int i = 0;i<al;i++){
            for(int e = i+1;e<al-i;e++){
                int temp;
				if(arr[i]>arr[e]){
                    temp = arr[i];
                    arr[i] = arr[e];
                    arr[e] = temp;
                }
                if(arr[al-i]<arr[al-e]){
                    temp = arr[al-i];
                    arr[al-i] = arr[al-e];
                    arr[al-e] = temp;
                }
            }
           
        }
        //打印数组
        System.out.print("[");
        for(int j = 0;j<arr.length;j++){
            if(j!=arr.length-1)
            System.out.print(arr[j]+",");
            else
                System.out.print(arr[j]);
        }
        System.out.print("]");
    }
}

优化前：

 public static void main(String[] args) {
        int arr[] = {5,3,2,1,4,7,9,8,6};
        int al = arr.length-1;
        for (int i = 0;i<al;i++){
            for(int e = i+1;e<al-1;e++){
                int temp;
				if(arr[i]>arr[e]){
                    temp = arr[i];
                    arr[i] = arr[e];
                    arr[e] = temp;
                }
            }
        }
        //打印数组
        System.out.print("[");
        for(int j = 0;j<arr.length;j++){
            if(j!=arr.length-1)
            System.out.print(arr[j]+",");
            else
                System.out.print(arr[j]);
        }
        System.out.print("]");
    }
}

将两个代码分别用两个线程执行，算出它们的排序时间
上代码：

public class Selection {

    //优化选择排序,一次i循环找出最小值和最大值。
    public static void main(String[] args) {

        Thread thread1 = new Thread(()->{
            System.out.println(Thread.currentThread()+"的执行时间是"+原始());
        });
        Thread thread2 = new Thread(()->{
            System.out.println(Thread.currentThread()+"的执行时间是"+优化());
        });
        thread1.setName("线程1");
        thread2.setName("线程2");
        thread1.start();
        thread2.start();
    }
		
	//创建无序数组
    public static int[] getArray(){
        int[] arr = new int[10000];
        Random random = new Random(500000);
            for (int i = 0;i<10000;i++){
                arr[i] = random.nextInt();
            }
            return arr;
    }

    public static Long 原始(){
        int arr[] = getArray();

        int al = arr.length-1;
        Long time = System.currentTimeMillis();
        for (int i = 0;i<al;i++){

            for(int e = i+1;e<al-1;e++){

                int temp;
				if(arr[i]>arr[e]){
                    temp = arr[i];
                    arr[i] = arr[e];
                    arr[e] = temp;
                }
            }
        }
        return System.currentTimeMillis()-time;
    }

    public static Long 优化(){
        int arr[] = getArray();

        int al = arr.length-1;
        Long time = System.currentTimeMillis();
        for (int i = 0;i<al;i++){

            for(int e = i+1;e<al-i;e++){

                int temp;
				if(arr[i]>arr[e]){
                    temp = arr[i];
                    arr[i] = arr[e];
                    arr[e] = temp;
                }
                if(arr[al-i]<arr[al-e]){
                    temp = arr[al-i];
                    arr[al-i] = arr[al-e];
                    arr[al-e] = temp;
                }
            }
        }
        return System.currentTimeMillis()-time;
    }

对500个数据排序结果图
对5000个数据进行排序结果图
对50000个数据进行排序 对200000数据进行排序（50w等的时间太长了）

可以看出优化过后的算法，确实起到了优化的作用，但是仅限于大数据量，因为小数据量来说，创建变量分配内存之类的，会造成一些影响，而且我只是在原来的时间上做了优化，空间优化和不稳定优化没有涉及到，若有不正之处，请谅解和批评指正，不胜感激！