排序二| 插入类排序(java实现)

插入排序的基本排序思想是：逐个考察每个待排序元素，将每一个新元素插入到前面已经排好序的序列中适当的位置上，使得新序列仍然是一个有序序列。在这一类排序中主要介绍三种排序方法：直接插入排序、折半插入排序(二分插入排序)和希尔排序。

直接插入排序

直接插入排序是一种最简单的插入排序方法，它的基本思想是：仅有一个元素的序列总是有序的，因此，对 n 个记录的序列，可从第二个元素开始直到第 n 个元素，逐个向有序序列中执行插入操作，从而得到 n 个元素按关键字有序的序列。

一般来说，在含有 j-1 个元素的有序序列中插入一个元素的方法是：从第 j-1 个元素开始依次向前搜索应当插入的位置，并且在搜索插入位置的同时可以后移元素，这样当找到适当的插入位置时即可直接插入元素。以关键字序列{ 26 , 53 , 48 , 11 , 13 , 48 , 32 , 15}为例，直接插入排序的过程下图所示。

直接插入排序的过程

 java代码实现：

public class InsertSort {
/**
 * 直接插入排序
 * @param args
 */
	    public static void main(String[] args) {
	        int[] a={49,38,65,97,76,13,27,49,78,34,12,64,1};
	        System.out.println("排序之前：");
	        for (int i = 0; i < a.length; i++) {
	            System.out.print(a[i]+" ");
	        }
	        //直接插入排序
	        for (int i = 1; i < a.length; i++) {
	            //待插入元素
	            int temp = a[i];
	            int j;
	            for (j = i-1; j>=0; j--) {
	                //将大于temp的往后移动一位
	                if(a[j]>temp){
	                    a[j+1] = a[j];
	                }else{
	                    break;
	                }
	            }
	            a[j+1] = temp;//插入进来
	        }
	        System.out.println();
	        System.out.println("排序之后：");
	        for (int i = 0; i < a.length; i++) {
	            System.out.print(a[i]+" ");
	        }
	    }
}

空间效率：仅使用一个辅存单元。

时间效率：假设待排序的元素个数为 n，则向有序表中逐个插入记录的操作进行了 n-1趟，每趟操作分为比较关键码和移动记录，而比较的次数和移动记录的次数取决于待排序列按关键码的初始排列。

⑴ 在最好情况下，即待排序序列已按关键字有序，每趟操作只需 1 次比较 0 次移动。此时有：总比较次数 = n-1 次；总移动次数 = 0 次。

⑵ 在最坏情况下，即待排序序列按关键字逆序排序，这时在第 j 趟操作中，为插入元素需要同前面的 j 个元素进行 j 次关键字比较，移动元素的次数为 j+1 次。此时有：

⑶ 平均情况下：即在第 j 趟操作中，插入记录大约需要同前面的 j/2 个元素进行关键字比较，移动记录的次数为 j/2+1 次。此时有：
总比较次数 ≈ 次；总移动次数 ≈ 次 由此，直接插入排序的时间复杂度为O(n2)，并且是一个稳定的排序方法。

折半插入排序(二分插入排序)

直接插入排序算法简便、容易实现。当待排序元素的数量 n 很小时，这是一种较好的排序方法，但是通常待排序元素数量 n 很大，则不宜采用直接插入排序方法，此时需要对直接插入排序进行改进。

直接插入排序的基本操作是向有序序列中插入一个元素，插入位置的确定是通过对有序序列中元素按关键字逐个比较得到的。既然是在有序序列中确定插入位置，则可以不断二分有序序列来确定插入位置，即搜索插入位置的方法可以使用折半查找实现。

java代码实现：

public class BinaryInsertSort {
    public static void main(String[] args) {
        int[] a={49,38,65,97,176,213,227,49,78,34,12,164,11,18,1};
        System.out.println("排序之前：");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }

        sort(a); //二分法插入方法
        System.out.println();
        System.out.println("排序之后：");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
    }

    //二分法插入
    private static void sort(int[] a) {
        for (int i = 0; i < a.length; i++) {
            int temp = a[i];
            int left = 0;
            int right = i-1;
            int mid = 0;
            //确定要插入的位置
            while(left<=right){
            	//先获取中间位置
                mid = (left+right)/2;
                if(temp<a[mid]){
                	//如果值比中间值小，让right左移到中间下标-1
                    right = mid-1;
                }else{
                	//如果值比中间值大,让left右移到中间下标+1
                    left = mid+1;
                }
            }
            for (int j = i-1; j >= left; j--) {
            	//以左下标为标准，在左位置前插入该数据，左及左后边全部后移
                a[j+1] = a[j];
            }
            if(left != i){
            	//左位置插入该数据
                a[left] = temp;
            }
        }
    }


}

折半插入排序所需的辅助空间与直接插入排序相同，从时间上比较，折半插入排序仅减少了元素的比较次数，但是并没有减少元素的移动次数，因此折半插入排序的时间复杂度仍为O(n2)。

希尔排序

希尔排序又称为“缩小增量排序”，它也是一种属于插入排序类的排序方法，是一种对直接插入排序的改进，但在时间效率上却有较大的改进。从对直接插入排序的分析中知道，虽然直接插入排序的时间复杂度为O(n2)，但是在待排序元素序列有序时，其时间复杂度可提高至O(n)。由此可知在待排序元素基本有序时，直接插入排序的效率可以大大提高。从另一方面看，由于直接插入排序方法简单，则在n值较
小时效率也较高。希尔排序正是从这两点出发，对直接插入排序进行改进而得到的一种排序方法。

希尔排序的基本思想是：首先将待排序的元素分为多个子序列，使得每个子序列的元素个数相对较少，对各个子序列分别进行直接插入排序，待整个待排序序列“基本有序”后，再对所有元素进行一次直接插入排序。

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

希尔排序过程的示意图如下：

希尔排序过程示意图(图片来源： https://www.cnblogs.com/chengxiao/p/6104371.html)

java代码实现：

public class HeerSort {

 //希尔排序   
    public static void main(String[] args) {
        int[] a={49,38,65,97,76,13,27,49,78,34,12,64,1,33,85,29};
        System.out.println("排序之前：");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
        //希尔排序
        System.out.println();
		//增量d初始值取长度的一半
        int d = a.length/2; 
        while(true){
            for(int i=0;i<d;i++){
                for(int j=i;j+d<a.length;j+=d){
                int temp;
                if(a[j]>a[j+d]){
                    temp=a[j];
                    a[j]=a[j+d];
                    a[j+d]=temp;
                    }
                }
            }
            if(d==1){break;}
            d--;
           }
        System.out.println();
        System.out.println("排序之后：");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
    }

}

从直观上我们可以预见希尔排序的效率会较直接插入排序要高，然而对希尔排序的时间复杂度分析是一个复杂的问题，因为希尔排序的时间复杂度与步长序列的选取密切相关，如何选择步长序列才能使得希尔排序的时间复杂度达到最佳，这还是一个有待解决的问题。