DS_【插入排序】

Java-四大排序
一、插入排序
（1）直接插入排序
直接插入排序 在执行操作中将一段新的数据插入已经排好了序列中。
例如：在进行身高排队中 来了一组没有排好序的队列，我们依据其身高大小进行排队
我们选取
1.第一个人 记为第一位 将第二位拿来与其进行比较，高则后小则前。这样就为第一个有序的序列
2.第三个人进入排序，依次与第一人第二人进行比较，就成为第二个有序序列
排序描述过程
一组无序序列 array[]

两个嵌套循环外层 i 表示依次拿到之后无序的数
内层 j 循环已经排好位置的有序数
1.从数组第一个数开始 拿到第一个数 依次放入比较器 tmp
array[] = tmp;
2.拿到第二个数与其比较小于交换位置

3，拿到第三个数放入tmp中 与之前排好的依次比较
与有序数组倒序比较 因为在有序数组中大数子在后面大于其不变

3.拿到第四个数字 与之前的有序数组从后向前比较如果小则把被比较的数字向后移动一个位置再向前，直到大于之前的数
拿到 7 放入tmp中 之前都是有序数组先与9比较 小于所以将九向后移动
发现7 大于之前的 数所以停止 到下一个。

在依次进行比较之后的数 就会得到一个有序的数组

算法描述过程
1.外层循环i拿到数放置tmp中
2.内层循环j将拿到的数与tmp比较 小于则将j移动到 j+1 大于则停止将有序数组最后一个j+1放入 tmp
代码实现

public static void insertSort(int[] array){
    int tmp=0;				//比较临时 tmp
    int j = 0;				
    for(int i = 1;i<array.length;i++){		//外层i 循环之后的无序数
       tmp = array[i];				//拿到之后放入tmp
       for(j=i-1;j>-1;j--){		//逆向遍历之前排好的有序数组
           if(array[j]>tmp){		//有序数组从后向前比较如果大于tmp
               array[j+1]=array[j];     //将当前元素前一个元素 移到当前位置  
           }else{		
               break;
           }
       }
       array[j+1]=tmp;		//此时将之前有序数组最大值放入tmp
    }
}

特点
1.元素越接近有序直接插入时间效率越高
10000个数据 有序排序时间396000纳秒 无序排序时间17132882纳秒
2.因为遍历两次嵌套 所以 时间复杂度 O（N²）
3.空间复杂度 只申请了一个tmp O（1）
4.没有交换数据所以 稳定排序
（2）希尔排序
升级版插入排序
当进行直接插入排序时我们发现，不论数据有多少时，我们总要从第一个数据进行开始遍历，当数据量十分巨大时且数组有序，我们还是要进行遍历，这是十分里浪费时间。

产生了希尔排序
1.先进行分组 对组内的成员进行插入排序
2.调整分组在进行排序
3.目的就是在每一次调整时让整个数组更加有序 在最后时候才会更加快
过程描述
1.对无序的数组进行分组
数据有限 先进行三三分组 两组
2.对每一个组进行第一次排序

3.调整分组 二二 分组 进行排序

4.全部分为一组进行排序
整个过程的思想，对目标数组，尽可能的在遍历之前调整最大程度的有序
代码实现

public static void shellSort(int[] array){
    int[] div = {5,3,1};
    for (int i = 0; i <div.length ; i++) {
        shell(array,div[i]);
    }
}
public static void shell(int[] array,int gap){
    int tmp=0;
int j = 0;
    for(int i = gap;i<array.length;i=i+gap){  //开始的位置选取为分组的位置
         tmp = array[i];
        for(j=i-gap;j>=0;j=j-gap){	//对每个组内的元素进行逆向遍历
            if(array[j]>tmp){               //比较当前j的值 和tmp的大小
                array[j+gap]=array[j];          //将当前分组元素的前一个元素 移到当前位置
            }else{
                break;
            }
        }
        array[j+gap]=tmp;
    }
}

代码优化
在进行排序时 代码分组十分重要关系到效率 人为修改的方式不符合Java的代码规则
通过不断地取对半达到分组效果

public static void shellSort2(int[] array){
    long start = System.nanoTime();
    int key = array.length;	//拿到数组长度
    while(key!=0){		
        key=key/2;		//每一次分组长度 
        for(int i = 0;i<key;i=i+key){	//经过测试 i=i+key 时间小于 i++
            int tmp = array[i];
            for(int j = i-key;j>-1;j=j-key){
                if(array[j]>tmp){
                    array[j+key]=array[j];
                }else{
                    break;
                }
                array[j+key]=tmp;
            }
        }
    }
    long end = System.nanoTime();
    System.out.println("希尔排序时间"+(end-start)+"纳秒");
}

总结：
1.组数越多时间越短
有序
希尔排序时间1778纳秒
无序
希尔排序时间1333纳秒
2.希尔排序是对插入排序的优化
3.稳定性 不稳定
4.平均的时间复杂度 O（N^{1.3）-------O（N}2）