几种简单排序算法

最近对java数据结构和算法的一些编程和总结，以博客形式开始记录:

一、冒泡排序:

    /**
         * 
         *   冒泡排序,两个相邻的比较大小 1、右侧为最大 2、左侧为最大
         *  10万条数据排序时间: 16234ms 30万:151927ms 
         *   大O分析: 
         *         比较次数: (N-1) + (N-2)+... = n*(n-1)/2 ~= n^2/2 
         *         交换次数: 随机较好情况: n^2 / 4 最差情况: n^2 / 2 
         *         大O表达:O(N^2)
         */
        public static void bubbleSort(long[] longArr) {
            staticArr = longArr;
            for (int i = 0; i < longArr.length-1; i++) {
                for (int j = 0; j < longArr.length - i - 1; j++) {
                    long a = longArr[j];
                    long b = longArr[j + 1];
                    if (a > b) {
                        swap(j, j + 1);
                    }
                }
            }
        }

二、选择排序:

    /**
     *     选择排序
     *     10万条数据排序时间:8241ms  30万:73639
     *     大O分析: 
     *         比较次数: (N-1) + (N-2)+... = n*(n-1)/2 ~= n^2/2 
     *         交换次数: N //当N较大时,选择排序较冒泡有优势
     *         大O表达:O(N^2)
     */
    public static void selectSort(long[] longArr) {
        //赋值只是将地址赋值了,对static的修改即使对longArr的修改
        staticArr = longArr;
        int min;
        for (int i = 0; i < longArr.length - 1; i++) {
            min = i;
            for (int j = i + 1; j < longArr.length; j++) {
                System.out.println("i:" + longArr[i]);
                if(longArr[j] < longArr[min]) {//说明j更小，将j的值先保留
                    min = j;
                }
            }
            swap(i, min);
        }
        System.out.println("change times:" + num);
    }

三:插入排序

/**
     *     插入排序
     *     10万条数据排序时间:4037 30万: 37070
     *     大O分析: 
     *         比较次数: 1 + 2 + 3 + 。。。。= n*(n-1)/2 ~= n^2/2 
     *         交换次数: N 比冒泡快一倍,比选择略快
     *         大O表达:O(N^2)
     * @param longArr
     */
    public static void insertSort(long[] longArr) {
        
        int j;
        for (int i = 1; i < longArr.length; i++) {
            long temp = longArr[i];
            j = i;
            while (j > 0 && longArr[j - 1] >= temp) {
                longArr[j] = longArr[j - 1];
                --j;
            }
            longArr[j] = temp;
        }
    }

四:奇偶排序

/**
     *     奇偶排序:

     *     大O分析: 
     *     比较次数: (N/2 -1) + (N/2 -2) + ... ~= n^2/8 
     *     交换次数: 因为 奇偶排序实质是将冒泡排序拆分，交换次数与冒泡差不多
     *     大O表达:O(N^2)
     *     10万 排序时间:10964
     *     30万 排序时间:111476
     * @param longArr
     */
    public static void oddEvenSort(long[] longArr) {
        staticArr = longArr;
        boolean sign = true;
        while (sign) {
            sign = false; //先置为false,如果有交换，下面会重新赋值true
            for (int i = 0; i < longArr.length - 1; i += 2) {//对所有的偶索引排序
                if (longArr[i] > longArr[i + 1]) {
                    swap(i, i + 1);
                    sign = true;
                }
            }
            for (int i = 1; i < longArr.length - 1; i += 2) {//对所有的奇索引排序
                if (longArr[i] > longArr[i + 1]) {
                    swap(i, i + 1);
                    sign = true;
                }
            }
        }
    }

排序效率为: 插入 > 选择 >  奇偶 > 冒泡

技术之渣渣,如有问题请指出！！！