java泛型实现插入排序与选择排序

选择排序

    //选择排序模板方法
    //http://www.cnblogs.com/xiaomiganfan/p/5390252.html 泛型相关

    public static<T extends Comparable<T>> void selectionSort(T[] arr, int n){
    for(int i=0; i<n; i++){
        //寻找[i,n)之间最小值
        int minIndex = i;
        for(int j=i+1; j<n; j++){
            if(arr[j].compareTo(arr[minIndex]) < 0){
                minIndex = j;
            }
        }
        T temp = arr[minIndex];
        arr[minIndex] = arr[i];
        arr[i] = temp;
    }
}

插入排序

    public static <T extends Comparable<T>> void InsertionSort(T arr[], int n){
        for(int i=1; i<n; i++){

            //寻找arr[i]合适的插入位置
            for (int j=i; j>0 && arr[j].compareTo(arr[j-1]) < 0; j--){
                T temp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = temp;
            }
        }
    }

运行结果

    public static void main(String[] args) {
        int n = 10000;
        int right = 100000;
        Integer arr1[] = getRandomNum(n, right);
        Integer arr2[] = new Integer[n];
        for(int i=0; i<n; i++) arr2[i] = arr1[i];

        long insertStartTime = System.currentTimeMillis();
        InsertSort.InsertionSort(arr1, n);
        long insertFinalTime = System.currentTimeMillis();
        long selectStartTime = System.currentTimeMillis();
        selectedSort.selectionSort(arr2, n);
        long selectFinalTime = System.currentTimeMillis();

        System.out.println("Insert Sort time is: "+
                (insertFinalTime-insertStartTime));
        System.out.println("Select Sort time is: "+
                (selectFinalTime-selectStartTime));
//        for (Integer ele: arr1 ) {
//            System.out.print(ele+" ");
//
//        }
//        System.out.println();
//        for (Integer ele: arr2 ) {
//            System.out.print(ele+" ");
//
//        }
//        System.out.println();

    }

Insert Sort time is: 250
Select Sort time is: 181

由于插入排序在遍历的同时进行交换，造成耗时比选择排序多

优化后的插入排序

    // 优化后的插入排序，将循环内的交换，变为赋值
    public static <T extends Comparable<T>> void OptInsertionSort(T arr[], int n){
        long optInsertStartTime = System.currentTimeMillis();
//        System.out.println("OptInsert");
        for(int i=1; i<n; i++){
            T temp = arr[i];
            //寻找arr[i]合适的插入位置
            int j;
            for (j=i; j>0; j--){
                if(arr[j-1].compareTo(temp)>0){
                    arr[j] = arr[j-1];
                }else{
                    break;
                }
            }
            arr[j] = temp;
        }
        long optInsertFinalTime = System.currentTimeMillis();
        System.out.println("OptInsert Sort time is: "+
                (optInsertFinalTime-optInsertStartTime));


    }

将内层循环内的交换变为赋值。

13 23 10 4 55

首先将23拷贝
用23前边的元素与23比较，如果比23大，则前边的元素后移一位。

实际结果

对数组排序算法优化后插入排序明显优于选择排序（暂未找到原因）

但是对模板算法来说，优化后的插入排序效率与选择相似，远好于优化前的插入排序。