java实现排序算法之插入排序（直接插入排序，折半插入排序，希尔排序）

插入排序：其基本思想就是每次将一个待排序的的记录，按其关键字大小插入到前面已经排好序的子序列中，直到全部记录插入完成，其主要的算法有：直接插入排序，折半插入排序，希尔排序，下面主要介绍这三个算法：

直接插入排序：这个比较简单

算法思想：就是第一个元素默认有序，然后从第二个元素开始，逐个向前插入，先寻找要插入位置，然后位置后元素整体后移一位，然后插入元素即可，比较好理解，代码也比较简单

稳定性：稳定

时空复杂度与初始状态是否有关：是

时间复杂度：

最好情况：O(n)——元素递增有序，比较次数为n次

最坏情况：O(n^2) ——元素递减有序，比较次数n(n-1)/2

平均情况：O(n^2)

空间复杂度：O(1)

下面java实现的代码：

public class Main {

	public static void main(String[] args) {
		int []a={4,9,2,7,1,8,9,5,3};
		directInsertSort(a);
		System.out.println(Arrays.toString(a));
	}
	public static void directInsertSort(int []a){
		for(int i=1;i<a.length;i++){//从第二个元素开始，逐渐向前插入
			
			/*	int temp=a[i];
			while(temp<a[i-1]){//while 循环实现元素后移
				a[i]=a[i-1];
				i--;
				if(i==0)break;
			}	
			a[i]=temp;
			*/
			int temp=a[i];
			int j=i-1;
			for(;j>=0&&temp<a[j];j--){//for循环实现，元素后移
				a[j+1]=a[j];
			}
			
			a[j+1]=temp;
		}
	}
}

折半插入排序：和直接插入排序相比唯一的区别就是确定插入位置的方式变成了折半查找

算法思想：第一个元素默认有序，从第二个元素开始，用折半查找方式向前查找插入位置，然后后移元素，插入即可

稳定性：稳定

时空复杂度与初始状态是否有关:无关

时间复杂度：O(n^2)

空间复杂度：O(1)

下面是java实现的代码：

public class Main {
	public static void main(String[] args) {
		int []a={4,9,2,7,1,8,9,5,3};
		binaryInsertSort(a);
		System.out.println(Arrays.toString(a));
	}
	
	public static void binaryInsertSort(int []a){
		for(int i=1;i<a.length;i++){
			int temp=a[i];
			int j=binarySearch(a, temp, 0, i-1);
			for(int b=i-1;b>=j;b--){//j后元素后移
				a[b+1]=a[b];
			}
			a[j]=temp;
		}
		
	}
	
	public static int binarySearch(int []a,int target,int low,int high){//target为要查找元素  low，high为数组中的查找范围
		
		while(low<=high){
			int mid=(low+high)/2;
			if(a[mid]<target)low=mid+1;//注意这里没有a[mid]=target的情况，这是和折半查找的区别，这里要找的是插入位置，并不是元素
			else high=mid-1;
		}
		return high+1;//为应插入之位置
				
	}

}

希尔排序：

算法思想：将待排序表分割成若干个若干个形如L[i,i+2d,i+3d,i+4d.........i+kd]的特殊字表，d为步长，分别进行直接插入排序，通过改变步长逐渐将整个表排列有序，最后对全体记录进行一次直接插入排序即可。

稳定性：不稳定

时空复杂度 与初始状态有关

时间复杂度：其时间复杂度依赖于增量序列 的函数，最坏情况下时间复杂度为O(n^2)

空间复杂度：O(1)

下面为java实现的代码：

public class Main {
	public static void main(String[] args) {
		int []a={4,9,2,7,1,8,9,5,3};
		shellSort(a);
		System.out.println(Arrays.toString(a));
		
	}

	public static void shellSort(int []a){
		for(int sl=a.length/2;sl>=1;sl=sl/2){//sl 即为steplength步长
			
			for(int i=sl;i<a.length;i++){//插入排序，从步长的第二个元素开始取出向前插入
				if(a[i]>a[i-sl])continue;//如果要插入元素比前一个元素要大，就没必要在执行插入后移操作
				int temp=a[i];
				int j=i-sl;
				for(;j>=0&&a[j]>temp;j=j-sl){//直接插入操作，比目标元素大的后移
					a[j+sl]=a[j];
				}
				a[j+sl]=temp;//插入位置，插入
			}
		}
	}
}

谢谢观看！