七种经典排序算法及Java实现

排序算法稳定性表示两个值相同的元素在排序前后是否有位置变化。如果前后位置变化，则排序算法是不稳定的，否则是稳定的。稳定性的定义符合常理，两个值相同的元素无需再次交换位置，交换位置是做了一次无用功。

下面为七种经典排序算法指标对比情况：

一、插入排序 InsertionSort

介绍：

插入排序的工作原理是，对于每个未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

步骤：

1. 从第一个元素开始，该元素可以认为已经被排序
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
3. 如果被扫描的元素（已排序）大于新元素，将该元素后移一位
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5. 将新元素插入到该位置后
6. 重复步骤2~5

排序演示：

/**
     * 插入排序算法
     * @param nums 被排序的数组
     * @param n 数组长度
     * 最坏情况：输入数组已反向排序  O（n2）； 最好情况：输入数组已排序  O（n）；平均情况：O（n2）
     * 由于插入排序其内层循环非常紧凑，对于小规模输入，插入排序是一种非常快的排序算法
     */
    public void InsertSort(int[] nums,int len){
        int j;
        for(int i=1;i<len;i++){
            int temp = nums[i];
            for(j=i;j>0;j--){
                if(temp < nums[j-1]){
                    nums[j] = nums[j-1]; //将所有在nums[i]之前的大于nums[i]的值都往后移一位
                }
                else break;
            }
            //移完所有大于nums[i]的值后，j刚好指向最靠前一个大于nums[i]的位置
            nums[j] = temp;
        }
        System.out.println("插入排序：");
        for (int i : nums) {
            System.out.print(i+" ");
        }
    }

二、希尔排序 ShellSort

介绍：

希尔排序，也称递减增量排序算法，实质是分组插入排序。由 Donald Shell 于1959年提出。希尔排序是非稳定排序算法。

希尔排序的基本思想是：将数组列在一个表中并对列分别进行插入排序，重复这过程，不过每次用更长的列（步长更长了，列数更少了）来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身还是使用数组进行排序。

例如，假设有这样一组数[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我们以步长为5开始进行排序，我们可以通过将这列表放在有5列的表中来更好地描述算法，这样他们就应该看起来是这样：

13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10

然后我们对每列进行排序：

10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45

将上述四行数字，依序接在一起时我们得到：[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]。这时10已经移至正确位置了，然后再以3为步长进行排序：

10 14 73
25 23 13
27 94 33
39 25 59
94 65 82
45

排序之后变为：

10 14 13
25 23 33
27 25 59
39 65 73
45 94 82
94

最后以1步长进行排序（此时就是简单的插入排序了）。

/**
     * 希尔排序算法
     * @param nums 被排序的数组
     * @param n 数组长度
     * 最坏情况：O（n2） 使用Hibbard增量的最坏情况：O（n^3/2）
     */
    public void ShellSort(int[] nums,int len){
        int increment;
        int temp,i,j;
        for(increment = len/2;increment > 0;increment /= 2){ //增量为len/2 len/4 len/8.....1
            for(i=increment;i<len;i++){ //对每个子序列进行插入排序
                temp = nums[i];
                for(j=i;j>=increment;j -= increment){
                    if(temp < nums[j-increment]){
                        nums[j] = nums[j-increment];
                    }
                    else
                        break;
                }
                nums[j] = temp;
            }
        }
        System.out.println("希尔排序：");
        for (int k : nums) {
            System.out.print(k+" ");
        }
    }
在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
以此类推，直到所有元素均排序完毕。