插入排序算法

它们都属于内部排序，也就是只考虑数据量较小仅需要使用内存的排序算法，他们之间关系如下：

 　　　　　　　　 

1，直接插入排序算法概述：

     插入排序的设计是 向有序的数组中快速插入一个新的元素 ,

     算法思想：把要排序的数组分为两部分，一部分是除去待插入元素的所有元素，一部分是待插入元素：排序序时先将第一部分排序完成，然后再插入新元素。（第一部分默认为数组第一个元素）

2，插入排序可分为：直接插入排序，折半插入排序（二分插入排序）、链表插入排序、希尔排序。

3、直接插入排序的理解：

               将数组中所有前面已经排序好的元素相比较，如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过为止。

4、算法描述：

（1）从第一个元素开始，该元素可以认为已经排序。

（2）取出下一个元素，在已经排序的元素序列中从后向前扫描

（3）如果该元素（已排序）大于新元素，将该元素移到下一位置

（4） 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置

（5）将新元素插入到该位置后

（6）重复步骤②~⑤

                 

   综合比较：

       在每次比较操作发现   当取出来的新元素小于或等于已排序的元素时，可以将已排序的元素移到下一位置，然后将取出来的新元素插入该位置{两位置颠倒}

接着再与前面已排序的元素比较。 【缺点】交换操作代价比较大。

     另外一种做法：将新元素取出（挖坑），从左到右依次与已排序的元素比较，如果已排序的元素大于取出的新元素，那么将该元素移动到下一个位置（填坑），

     接着再与前面的已排序的元素比较，直到找到已排序的元素小于等于新元素的位置，这时再将新元素插入进去。就像基本思想中的动图演示的那样。

         如果比较操作的代价比交换操作大的话，可以采用二分查找法来减少比较操作的数目。可以认为是插入排序的一个变种，称为二分查找插入排序。

3、代码实现

public class InsertSort {
    
     public static void main(String[] args) {
         int[] ab=new int[]{2,4,3,1,5};
         System.out.println("数组长度："+ab.length);
         //遍历数组
        // outArray(ab);
         //打印数组
         System.out.println("数组："+Arrays.toString(ab));
         //1,直接插入排序
         insertSort(ab);
         
         System.out.println("==============================");
         //2,二分插入排序
         insertSortByTwo(ab);
         
    }
     
     //遍历数组
     public static void outArray(int[] a){
         System.out.print("数组元素：");
         //缺点无法修改下标
         for(int b:a){
             System.out.print(b+",");
         }     
     }
   
     /**
      * 插入排序
      *
      * 1. 从第一个元素开始，该元素可以认为已经被排序
      * 2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
      * 3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
      * 4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
      * 5. 将新元素插入到该位置后
      * 6. 重复步骤2~5
      * @param arr  待排序数组
      */
     public static void insertSort(int[] arr){
         
         for(int i=0;i<arr.length-1;i++){
             for(int j=i+1;j>0;j--){
                 if(arr[j]>arr[j-1])break;
                 int temp=arr[j];
                 arr[j]=arr[j-1];
                 arr[j-1]=temp;
             }
         }
         System.out.println("排序数组："+Arrays.toString(arr));
     }
     
     //二分插入排序
     public static void insertSortByTwo(int[] arr){
         for(int i=0;i<arr.length;i++){
             int temp=arr[i];
             for(int j=i;j>0;j--){
                 if(j>0&&arr[j-1]>temp){
                     arr[j]=arr[j-1];//将排好序的后移
                 }else {
                    arr[j]=temp;//新元素插入该位置
                    break;
                }
             }
         }
     System.out.println("二分排序数组："+Arrays.toString(arr));
     }
 
}

直接插入排序复杂度如下：

• 最好情况下，排序前对象已经按照要求的有序。比较次数(KCN)：n−1n−1；移动次数(RMN)为00。则对应的时间复杂度为O(n)O(n)。
• 最坏情况下，排序前对象为要求的顺序的反序。第i趟时第i个对象必须与前面i个对象都做排序码比较，并且每做1次比较就要做1次数据移动（从上面给出的代码中看出）。比较次数(KCN)：∑n−1i=1i=n(n−1)2≈n22∑i=1n−1i=n(n−1)2≈n22 ; 移动次数(RMN)为：∑n−1i=1i=n(n−1)2≈n22∑i=1n−1i=n(n−1)2≈n22。则对应的时间复杂度为O(n2)O(n2)。
• 如果排序记录是随机的，那么根据概率相同的原则，在平均情况下的排序码比较次数和对象移动次数约为n22n22，因此，直接插入排序的平均时间复杂度为O(n2)O(n2)。

平均时间复杂度	最好情况	最坏情况	空间复杂度
O(n²)	O(n)	O(n²)	O(1)

Tips: 由于直接插入排序每次只移动一个元素的位， 并不会改变值相同的元素之间的排序， 因此它是一种稳定排序。