排序-----直接插入排序及其优化（java）

 

算法思想：

直接插入排序是将整个数组分为有序数组和无序数组，有序数组是由比较过的元素组成的，而无序数组就是还没有进行比较的元素组成的。插入排序通过构建有序序列，对于没有排序元素，在已排序序列中从后向前扫描，找到相应位置并插入 ，重复该操作，直到最后一个元素排序完成。到此完成序列排序。 

算法分析： 
1） 从序列的第一个元素开始，但是第一个元素默认已经被排序 
2）取出下一个元素，设它为待插入元素，在已经排序的元素序列中从后向前扫描，如果被比较元素（已排序）大于待插入元素，将该元素向后移动一位，即移到下一位置。 
3） 重复步骤2，直到找到已排序的元素小于或者等于待排序元素的位置，插入待排序元素 
4.）重复2，3步骤，直到把数组最后一个待排序元素插入到已排序数组中，排序结束。

方法一：利用两层循环，第一次是排序的次数，第二层是待排序元素想要插入到已排序元素中的比较次数。在第二层中如果 待排序元素小于已排序元素，他们就交换位置 。直到待排序元素大于已排序元素，该趟排序完成，进入下一趟排序。直到所有的数都排序完成，排序结束。

 //方法一：
    public static void insertSort1(int[] arr,int len) {
        for(int i=0;i<len-1;i++){//排序次数
            for(int j=i+1;j>0;j--){//内部比较次数
                if(arr[j]<=arr[j-1]){//如果前一个数比后一个数大，两个数交换
                    int tmp=arr[j];
                    arr[j]=arr[j-1];
                    arr[j-1]=tmp;
                }
            }
        }
    }


方法二：挖坑法
   public static void insertsort2(int[] array){
        for (int i = 1; i <array.length ; i++) {//外部排序的册数
           //定义要插入的数
            int insertVal=array[i];
            //保存要插入数的前一个下标，去找要插入的位置
            int insertindex=i-1;
            /*
            向前找到要插入的位置
            说明：
            1.insertIndex>=0  保证在找到insertVal位置时，不越界
            2.insettVal<array[insertIndex]:待插入的数还没有找到插入的位置
            3.需要将insertIndex向前移动向到要插入的位置

            注意：如果小下昂从达到小排列：insertVal>array[insertindex]
             */
            while(insertindex>=0&&insertVal<array[insertindex]){//从小到大排序
                array[insertindex+1]=array[insertindex];//前边的数大于要插入的数，insertIndex继续向后移动
                insertindex--;//继续向前找要插入的位置
            }
            //当退出while循环时，说明插入的位置已经找到了，insertIndex+1
            //如果在对应的位置就不需要复值
            if(insertindex+1!=i){
                array[insertindex+1]=insertVal;
            }
        }
    }

 

方法二：优化查找和插入

主要是对查找插入位置和插入进行了合并，减少了多余的比较。

 

    /**方法二：优化你版本
     *思想：主要是对查找位置和后边插入进行了合并，减少了多余的比较
     */
    public static void insertSort2(int[] arr,int len){
        for(int i=1;i<len;i++){//外部的比较次数
            //优化地方：如果前面的数比后边的数小，说明前边的数是有序的
            if(arr[i]<arr[i-1]){
                int tmp=arr[i];//挖坑：保存当前arr[i]的值，
                //优化：arr[j]>tmp（如果条件不成立，说明前边的数都比tmp小），把arr[i]之前的数进行比较
                for(int j=i-1;j>=0&&arr[j]>tmp;j--){
                    arr[j+1]=arr[j];
                    arr[j]=tmp;
                }
            }
        }
    }

 

方法三：折半插入

它优化了查找待排序元素的位置，减少了比价次数

/**方法3：折半插入
     * 思想：把要排序的元素，折半插入到前边有序元素中
     */
    public static void insertSort3(int[] arr,int len){
        for(int i=1;i<len;i++){
            if(arr[i]<=arr[i-1]){
                int high=i-1;//右边界
                int low=0;//左边界
                int  temp=arr[i];//要向前边插入的元素  坑
                //查找要插入的位置
                while(low<=high){
                    //记录中间位置
                    int mid=(low+high)/2;
                    //查找插入的具体位置
                    if(arr[mid]<temp){
                        low=mid+1;
                    }else{
                        high=mid-1;
                    }
                }
                //将mid(low)~i处的元素，都向后移动一位
                for(int j=i;j>low;j--){
                    arr[j]=arr[j-1];
                }
                arr[low]=temp;
            }
        }
    }

时间复杂度：

小tips：

插入排序所需的时间取决于输入元素的初始顺序。例如，对一个很大且其中的元素已经有序(或接近有序)的数组进行排序将会比随机顺序的数组或是逆序数组进行排序要快得多