Java 数据结构（一）---排序（一） 插入排序

一、排序概述与分类

1、概念

把一组数据按照一定的条件进行排列。例如按照数字大小进行排列，1、2、3、4、5、6；
2、分类
1）内存排序，外存排序

2） 稳定排序与不稳定排序
考虑的相同关键字在排序过程中发生变化，则称所用的排序方法是不稳定的，若未发生变化则是稳定的。
3）简单排序与高效排序
简单排序：一般将平均时间复杂度O（n^2）的排序算法。例如直接插入排序、简单选择排序、冒泡泡排序等。

高效排序：速度较快的其他排序算法。

2、排序算法好坏的评价标准：

1. 对n个记录的文件排序所需比较关键字的次数。
2. 对n个记录的文件排序所需移动的次数。
3. 排序过程中所需要的辅助存储空间大小。
   注意：时间复杂度不仅依赖于问题的规模，还取决于输入数据的状态，因此，对于排序的算法将讨论其最好，最坏，平均三种情况的时间复杂度。

3、下图描述了几种常见的经典排序方法。

二、插入排序法

1、基本思想

每次将一个待排序的记录，按其关键字大小插入到前面已经排序好的有序子文件中，使得插入后仍保持该区间里记录是按关键字有序的，直到全部的记录插入完为止。插入排序有直接插入排序，折半插入排序，希尔排序等。

2、直接插入排序

1）过程：先将第一个记录看作是一个有序的记录序列。然后从第二个记录开始，依次将未排序的记录插入到这个有序的记录中去，直到整个文件中的全部记录排序完毕。
例如 有关键字序列（43 21 89 15 （43） 28） ，43是关键字。按照从小到大排序

。。。。	监视哨	已排序的	未排序的
初始关键字	（）	43	21 89 15 43 28
i=2	（21）	21 43
i=3	（21）	21 43 89
i=4	（15）	15 21 43 89
i=5	（43）	15 21 43 （43） 89
i=6	（28）	15 21 28 43 （43） 89

流程图：

Java 代码：

    public void directInsertSort(int[] array) {
        int i, j;
        for (i = 2; i < array.length; i++) {
            if (array[i] < array[i - 1]) {
                array[0] = array[i];
                j = i - 1;
                while (array[0] < array[j]) {
                    array[j + 1] = array[j];
                    j--;
                }
                array[j + 1] = array[0];
            }
        }
    }

下面结果的第一位数字是监哨位。

输入结果是：0,43,21,89,15,43,28
输出结果是：28  15  21  28  43  43  89  

C/C++写的话，可以直接按照java代码，也可以把形参设为&array[],int n;

评价：算法简洁，容易实现，辅助空间只有array[0];如果不适用array[0]作为监哨位，需要判断临界问题。
时间复杂度为O（n^2）；

3、希尔排序法（缩减增量排序 diminiishing increment sort)

1） 基本思想：

1. 先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序；
2. 然后依次缩减增量再进行排序；
3. 待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。

因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。

希尔排序法本职就是 分割 成几块。内部进行直接插入排序

2）流程图

    public void shellSort1(int[] array) {
        int i, j, gap;
        // 步长
        for (gap = array.length / 2; gap > 0; gap /= 2)

            // 直接插入排序
            for (i = 0; i < gap; i++) {
                for (j = i + gap; j < array.length; j += gap)

                    if (array[j] < array[j - gap]) {
                        int temp = array[j];
                        int k = j - gap;
                        while (k >= 0 && array[k] > temp) {
                            array[k + gap] = array[k];
                            k -= gap;
                        }
                        array[k + gap] = temp;
                    }
            }
    }

    public void shellSort2(int[] array) {
        int j;
        // 步长
        for (int gap = array.length / 2; gap > 0; gap /= 2)
            // 直接插入排序
            for (int i = gap; i < array.length; i++) {
                int tmp = array[i];
                for (j = i; j >= gap && (tmp < array[j - gap]); j -= gap)
                    array[j] = array[j - gap];
                array[j] = tmp;
            }
    }

随机数长度为一万的数组：

directInsertSort运行时间71
shellSort1 运行时间2
shellSort2运行时间1

随机数长度为十万的数组：

directInsertSort运行时间7227
shellSort1 运行时间5
shellSort2运行时间5

三、交换排序法

四、选择排序法

五、归并排序法

六、基数排序法