插入排序算法学习归纳-java实现

学习了插入排序算法，记录下以作备查

public class InsertSort {

	public static void main(String[] args) {
		int[] data = {261,53,48,11,13,48,32,15}; 
//		binsort(data);
//		data = new int[]{261,53,48,48,32,15,13,11};
//		binsort(data);
//		sort2(data);
		data = new int[]{261,53,48,48,32,15,13,11};
//		sort.sort2(data);
		shellsort(data);
		for(int a: data){
			System.out.print(a+" ");
		}
	}

	/**
	 * 这样排序很失败
	 */
	public static void sort(int[] r){
		int bi=0,ci=0;
		for(int c=0; c<r.length; c++){
			for(int i=0; i< c; i++){ 
				bi++;
				if(r[c] < r[i]){
					//插入i。后移					
					int temp = r[c];
					for(int j=c;j>i;j--){
						r[j] = r[j-1];
						ci++;
					}
					r[i] = temp;
				}
			}		
		}
		System.out.println("比较="+bi+",移动="+ci);
	}

	/**
	 * 正宗的插入排序
	 */
	public static void sort2(int[] r){
		int bi=0,ci=0;
		//从第2个数据开始
		for(int i=1; i< r.length; i++){
			bi++;
			if(r[i] < r[i-1]){//如果比有序的最后一个小，则需要插入到前面的有序数据中
				int temp =  r[i];//保存该值，因为会被移动替换掉
				r[i] = r[i-1];//先把最后一个数据交换，无论是否需要移动，该值一定会被交换
				int j = i-2;//有序的倒数第二个
				for(;j>=0 && temp < r[j]; j--){//不越界范围类倒数找到(不断比较查找)插入位置，并且移动
					r[j+1] = r[j];
					ci++;
				}
				//替换
				r[j+1]  = temp;				
			}
		}

		System.out.println("比较="+bi+",移动="+ci);
	}

	/**
	 * 折半插入排序
	 */
	public static void binsort(int[] r){
		int bi=0,ci=0;

		for(int i=1; i< r.length; i++){
			int temp = r[i];//保存
			int hi = i-1, lo = 0;//查找区间
			while(lo <= hi){
				int mid = (hi + lo)/2;
				if(temp < r[mid]){
					hi = mid - 1;//折半最后一步
				}else{
					lo = mid + 1;
				}
				bi++;
			}
			//折半查找，查找到比r[hi]大比r[lo]小的这个位置
			for(int j=i-1; j> hi;j--){//移动
				r[j+1] = r[j];
				ci++;
			}
			r[hi+1] = temp;//插入
		}
		System.out.println("比较="+bi+",移动="+ci);
	}

	/**
	 * 希尔排序
	 */
	public static void shellsort(int[] r){
		int[] delta = {5,3,1};
		for(int k=0; k < delta.length; k++){
			shellInsert(r, 0, r.length -1, delta[k]);
		}
	}

	/**
	 * 以某步长进行希尔排序
	 */
	private static void shellInsert(int[] r, int low, int high, int delta){
		for(int i= low + delta; i<=high; i++){
			if(r[i] < r[i-delta]){
				int temp =  r[i];//保存该值，因为会被移动替换掉 
				int j = i-delta;//有序的倒数第二个
				for(;j>=low && temp < r[j]; j-=delta){//不越界范围类倒数找到(不断比较查找)插入位置，并且移动
					r[j+delta] = r[j]; 
				}
				//替换
				r[j+delta]  = temp;		
			}
		}
	}
}