学习JAVA必会的排序——插入排序

插入排序（Insertion sort）是一种简单直观且稳定的排序算法。

插入排序的工作方式非常像人们排序一手扑克牌一样。开始时，我们的左手为空并且桌子上的牌面朝下。然后，我 们每次从桌子上拿走一张牌并将它插入左手中正确的位置。为了找到一张牌的正确位置，我们从右到左将它与已在 手中的每张牌进行比较，如下图所示：

 需求：

排序前：{4,3,2,10,12,1,5,6}

排序后：{1,2,3,4,5,6,10,12}

 排序原理：

1.把所有的元素分为两组，已经排序的和未排序的；

2.找到未排序的组中的第一个元素，向已经排序的组中进行插入；

3.倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待 插入元素放到这个位置，其他的元素向后移动一位；

         第一趟排序，先默认0索引处的元素4是已排序的，而后面的索引1、2......我们认为还没有排序。接下来我们从未排序的元素中取出第一个位置的元素向已排序的序列中插入，怎么插入？我们只需遍历已排序的元素，和已排序的元素进行比较。注意：遍历的时候要倒序遍历，比已排序的元素小，就交换位置。

 解释一下，以第二趟排序为例：

        已排序序列里数据为（3、4），未排序的是2、10、12、1、5、6

        从未排序的序列中找出第一个位置的元素2，倒序遍历已排序的序列，先拿出4,2比4小，元素2和元素4交换位置（3、2、4）；继续来看：元素2和元素3，元素2比3小，继续交换（2、3、4）；最终（2、3、4）成为已排序的序列。

 以此类推：第三趟排序：

已排序列（2、3、4），未排序的是10、12、1、5、6

        从未排序的序列中找出第一个位置的元素10，和4、3、2分别比较，均不交换元素-->（2、3、4、10）

注意：当我们拿未排序的元素和已排序的元素进行比较时，如果比到未排序的元素比已排序的元素中的一个元素大的时候，就不需要继续向前比较了，因为往前的元素均比未排序的元素小。

插入排序API设计：

类名	Insertion
构造方法	Insertion()：创建Insertion对象
成员方法	1.public static void sort(Comparable[] a)：对数组内的元素进行排序 2.private static boolean greater(Comparable v,Comparable w):判断v是否大于w 3.private static void exch(Comparable[] a,int i,int j)：交换a数组中，索引i和索引j处的值

和选择排序、冒泡排序api类似，类名不同而已

        由于序列索引0处的元素默认以排序，因此待排序的元素从索引1开始，第一趟从索引1开始，第二趟从索引2开始......

public class Insert {
    /*
对数组a中的元素进行排序
*/
    public static void sort(Comparable[] a){
        for (int i=1;i<a.length;i++){
//当前元素为a[i],依次和i前面的元素比较，找到一个小于等于a[i]的元素
            for (int j=i;j>0;j--){
                if (greater(a[j-1],a[j])){
//交换元素
                    exch(a,j-1,j);
                }else {
//找到了该元素，结束
                    break;
                }
            }
        }
    }
    /*
    比较v元素是否大于w元素
    */
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }
    /*
    数组元素i和j交换位置
    */
    private static void exch(Comparable[] a,int i,int j){
        Comparable t = a[i];
        a[i]=a[j];
        a[j]=t;
    }
}

插入排序的时间复杂度分析

插入排序使用了双层for循环，其中内层循环的循环体是真正完成排序的代码，所以，我们分析插入排序的时间复 杂度，主要分析一下内层循环体的执行次数即可。

最坏情况，也就是待排序的数组元素为{12,10,6,5,4,3,2,1}，那么：

比较的次数为： (N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

交换的次数为： (N-1)+(N-2)+(N-3)+...+2+1=((N-1)+1)*(N-1)/2=N^2/2-N/2;

总执行次数为： (N^2/2-N/2)+(N^2/2-N/2)=N^2-N;

按照大O推导法则，保留函数中的最高阶项那么最终插入排序的时间复杂度为O(N^2).