算法入门---java语言实现的插入排序小结

public class InsertSort {

/**

*你想啊，每个的前面都是比它小的，这样的组合肯定是有序的啊，细分到最小，每一个都需要遵守规则，

* 这样就保证了前面的所有的，即使没和我挨着那么也是都比我小的。

* 插入排序的思想：

*   元素从前往后，第一个元素排在它应该排的位置，然后去遍历第二个元素插入到它合适的位置，

*   然后依次这样，那么怎么算是它合适的位置那？就是前面要么它是第一个了，要么前面的数比它小了

*   这就证明它已经找好自己的位置可以退出查找了，每个数都按照这样来，直到最后排好序

* @param src 数据源.

*/

public static void sort(int[] src){

int len = src.length;

//第一个数认为有序不需要比较，所以从第一个开始

//此时的索引是将要插入的元素.

for(int i = 1;i<len;i++){

//j索引应该是i后面的哪一个，依次和前一个比较找到自己合适的位置就可以退出这个循环，或者走到了最前面.

//当发现前面的比自己大的时候就需要交换位置(个人感觉是不是可以吧选择排序合入？)

/*for(int j = i;j>0;j--){

if(src[j]<src[j-1]){

int temp = src[j-1];

src[j-1] = src[j];

src[j] = temp;

}else{

break;

}

}*/

//可以简化成这样,注意是从i开始，而不是i+1.不要到最后一个i+1越界。

for(int j = i;j>0 && (src[j]<src[j-1]);j--){

int temp = src[j-1];

src[j-1] = src[j];

src[j] = temp;

}

}

}

}

          插入排序的一个特性就是，中途可能会退出，不许要完全比较完未排序的序列。

          时间复杂度：

          最坏的情况就是到序的时候，插入第2个元素时要比较前1个元素，插入第3个元素时，要比较前2个元素，……，插

入第N个元素，要比较前 N - 1 个元素。因此，最坏情况下的比较次数是 1 + 2 + 3 + ... + (N - 1)也就是 N^2 / 2，所以最坏

情况下的复杂度为 O(N^2)。

          最好情况下，数组已经是有序的，每插入一个元素，只需要比较前一个元素，(比较完就退出了)因此最好情况下，

插入排序的时间复杂度为O(N)

          实测平均用时：

10000

name: 冒泡排序1 花费了 = 73ms

name: 冒泡排序2 花费了 = 67ms

name: 冒泡排序3 花费了 = 58ms

name: 冒泡排序4 花费了 = 58ms

name: 冒泡排序5 花费了 = 60ms

平均：51

50000

name: 冒泡排序1 花费了 = 1684ms

name: 冒泡排序2 花费了 = 1660ms

name: 冒泡排序3 花费了 = 1486ms

name: 冒泡排序4 花费了 = 1436ms

name: 冒泡排序5 花费了 = 1482ms

平均：1549

100000

name: 冒泡排序1 花费了 = 6742ms

name: 冒泡排序2 花费了 = 6700ms

name: 冒泡排序3 花费了 = 5880ms

name: 冒泡排序4 花费了 = 5888ms

name: 冒泡排序5 花费了 = 5848ms

平均：6211

        总的看起来还是比选择排序用时长，比冒泡排序用时短。它能中断所以比冒泡短，但是即使它可以中断，但交换的
次数相对于选择排序还是非常的多的，而一次的交换就意味着三次的赋值。

但是它可以改进，对插入排序进行改进，核心是利用每次需要交换元素时换成赋值的，把前面比较大的元素复制到它的后

一个索引所在的位置(这个位置最开始的是要插入的那个元素，拿出来保留住)，一直到最后，再把前面保留住的元素存入
到最后空出来的这个合适的位置。
       改进后的代码如下：

/**

* 改进后的插入排序。

*  核心改进思想：当发现比前面数据小的时候不是每次都要交换，而是通过赋值。

*  先把最初的元素的值取出来保存，把当前位置往后赋值。循环到最后，再把取出来的数放入空出的位置。

* @param src 数据源

*/

public static void betterInsertSort(int[] src){

int len = src.length;

for(int i = 1;i<len;i++){

//先把需要插入到指定序列的元素拿出来，用于最后确定位置的时候进行插入。

int e = src[i];

int j;//为了方便最后出来的时候最后的赋值。

//比较拿出来的那个元素和前面各个元素的大小。注意从j-1开始。

for(j=i;j>0&&(e<src[j-1]);j--){

//由于e小于j-1索引对应的数，那么把j-1索引对应的数赋值到j上，向后移动而不是交换。

src[j] = src[j-1];

}

//循环完毕后,此时e>j或者j == 0了。一直比较的是j是当前索引，不符合的时候j-1赋值给j，然后j往前动1。

//此时还是比较当前所以，不符合那么直接把拿出来的放这即可。

src[j] = e;

}

}

        改进后的实测时间：

10000

name: 冒泡排序1 花费了 = 47ms

name: 冒泡排序2 花费了 = 39ms

name: 冒泡排序3 花费了 = 17ms

name: 冒泡排序4 花费了 = 17ms

name: 冒泡排序5 花费了 = 20ms

平均：28

50000

name: 冒泡排序1 花费了 = 949ms

name: 冒泡排序2 花费了 = 934ms

name: 冒泡排序3 花费了 = 414ms

name: 冒泡排序4 花费了 = 418ms

name: 冒泡排序5 花费了 = 421ms

平均：627

100000

name: 冒泡排序1 花费了 = 3892ms

name: 冒泡排序2 花费了 = 3824ms

name: 冒泡排序3 花费了 = 1708ms

name: 冒泡排序4 花费了 = 1674ms

name: 冒泡排序5 花费了 = 1710ms

平均：2561

         对比别的博客的数据值可以看出来平均来说已经比插入快了，就是因为它有可能会中断，不需要每次都查询到未排
序序列的最后。

稳定性：稳定。
      你想啊，只有小于的时候才进行插入，不然直接就break了。