Java实现经典排序算法及复杂度稳定性分析

        /* 冒泡排序 */  
        public static int[] bubbleSort(int[] arry) {  
            for (int i = 0; i < arry.length; i++) {  
                for (int j = i; j < arry.length - i - 1; j++) {  
                    if (arry[j] > arry[j + 1]) {  
                        int temp = arry[j];  
                        arry[j] = arry[j + 1];// 交换顺序，大的在后，小的在前  
                        arry[j + 1] = temp;  
                    }  
                }  
            }  
            return arry;  
        }  

/* 插入排序 */  
/* 
 * 基本思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的字序列的合适位置（从后向前找到合适位置后） 
 * 直到全部插入排序完为止。(类似于扑克牌抓牌) 
 */  
public static int[] insertSort(int[] arry) {  
    // 从数组第二位开始，第一位为初始排好的顺序  
    for (int i = 1; i < arry.length; i++) {  
        int temp = arry[i];// 保存待插入的数值  
        int j = i - 1;// 当前数值的前一位数组角标  
        for (j = i - 1; j >= 0; j--) {  
            if (arry[j] > temp) {  
                arry[j + 1] = arry[j];// 将前一位数值移动一位（内部循环比较找到要最后要插入的位置）  
            } else {  
                break;  
            }  
        }  
        arry[j + 1] = temp;// 将待插入的数值插入合适的位置  
    }  
    return arry;  
}

    /* 简单选择排序 */  
    /* 
     * 基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换； 
     * 然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。 
     */  
    public static int[] choiceSort(int[] arry) {  
        for (int i = 0; i < arry.length; i++) {  
            int low = i;  
            for (int j = i + 1; j < arry.length; j++) {  
                if (arry[j] < arry[low]) {  
                    low = j;// 寻找最小数值位置  
                }  
            }  
            // 将当前第一个元素与它后面序列中的最小的一个 元素交换，也就是将最小的元素放在最前端  
            int temp = arry[i];  
            arry[i] = arry[low];  
            arry[low] = temp;  
        }  
        return arry;  
  
    }

    /* 快速排序 */  
    /* 
     * 基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素, 通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素, 
     * 此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。 
     *  
     * 一趟快速排序的算法是： 
        1）设置两个变量i、j，排序开始的时候：i=0，j=N-1； 
        2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]； 
        3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换； 
        4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换； 
        5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i] 
                          不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行 
                          交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。 
     */  
    public static int[] quickSort(int[] arry, int low, int high) {  
        if (low < high) {  
            int middle = getMiddle(arry, low, high);  
            quickSort(arry, 0, middle - 1);//递归快排左边这个部分  
            quickSort(arry, middle + 1, high);//递归快排右边这个部分  
        }  
        return arry;  
  
    }

private static int getMiddle(int[] arry, int low, int high) {  
    int temp = arry[low];// 基准元素  
    while (low < high) {  
        while (low < high && arry[high] >= temp) {  
            high--;//从最右边往左找小于基准的元素  
        }  
        arry[low] = arry[high];//交换位置，小的在基准元素左边  
        while (low < high && arry[low] <= temp) {  
            low++;//从基准元素的右边找大于它的元素  
        }  
        arry[high] = arry[low];//交换位置，大的在基准元素右边  
    }  
    //当low == high，完成一趟快速排序  
     arry[low] = temp;  
    return low;  
}

平均时间复杂度比较：

冒泡：O(n^2)
插入：O(n^2)
选择：O(n^2)
快排：O(nlgn)

稳定性：

冒泡：稳定
插入：稳定
选择：不稳定

快排：不稳定

转载自：http://blog.csdn.net/u013812939/article/details/46739923点击打开链接