Java 选择排序 优化

常见的选择排序：

public static<E extends Comparable<E>> void sort(E[] data){
        for (int i = 0 ;i <= data.length-2; i ++){
            int minIndex = i;
            for (int j = i+1; j < data.length; j++){
                if (data[j].compareTo(data[minIndex]) < 0){
                    minIndex = j;
                }
            }
            if (minIndex != i){
                swap(data,i,minIndex);
            }
        }
    }

private static <E extends Comparable<E>> void swap(E[] data,int i,int j){
        E tmp = data[i];
        data[i] = data[j];
        data[j] = tmp;
    }

对代码进行简单分析

时间复杂度：O(n*n)

循环不变量：[ 0,,,,,,,,,i ]是有序的

优化后的选择排序：

public static<E extends Comparable<E>> void sort2(E[] data){
        for (int i = 0; i < data.length/2; i++) {
            int minIndex = i;
            int maxIndex = data.length - 1 - i;
            int start = minIndex;
            int end = maxIndex;
            for (int j = start; j <= end ; j++) {
                if (data[j].compareTo(data[minIndex]) < 0){
                    minIndex = j;
                }
                if (data[j].compareTo(data[maxIndex]) > 0){
                    maxIndex = j;
                }
            }
            if (maxIndex == minIndex){
                return;
            }else if (maxIndex == start && minIndex == end){
                swap(data,maxIndex,minIndex);
            }else if (maxIndex == start){
                swap(data,end,maxIndex);
                swap(data,start,minIndex);
            }else if (minIndex == end){
                swap(data,minIndex,start);
                swap(data,maxIndex,end);
            } else {
                swap(data,i,minIndex);
                swap(data,data.length - 1 - i,maxIndex);
            }
        }
    }

实现思路

在未排序的元素中同时找到最大和最小元素，小的元素放在数组前端，大的元素放在数组末端

简单分析 ：

时间复杂度：O(n*n)，但是算法当数据规模为n时，只需要循环约 n/2 次

循环不变量：[0,,,,,i]，[n-1-i,,,,,,n-1]各自有序

结果：

 

 结论：优化效果不明显

代码有bug，或者可以改进，或者其他问题，欢迎留言