冒泡，简单选择，直接插入，二分法插入，希尔排序

package Algorithm;

public class JavaAlgorithm {
	/**
	 * 冒泡排序；O(n*n)
	 */
	public void bubbleSort(int [] array) {
		int temp;
		int count = 0;
		for(int i =0;i<array.length-1;i++) {
			for(int j=0;j<array.length-1-i;j++) {
				if(array[j]>array[j+1]) {
					temp = array[j];
					array[j]= array[j+1];
					array[j+1] = temp ;
					count ++;
				}
			}
		}
		System.out.println("冒泡排序交换位置："+count+"次！");
	}
	/**
	 * 选择排序:
	 * 	外层循环，i从小到大；
	 *  内层循环，j从外层下标i开始,递增；
	 *  min=array[i],内层循环找到比min小的，两个元素交换位置
	 *  min = 较小的;
	 * @param array
	 */
	public void chooseAlgorithm(int [] array) {
		int count = 0;
		int temp;
		for(int i =0;i<array.length;i++) {
			int min = i;
			int j = 0;
			for(j =i+1;j<array.length;j++) {
				if(array[min]>array[j]) {
					min = j;
				}
			}
			if(min != i) {
				temp = array[min];
				array[min] = array[i];
				array[i] = temp;
				count ++;
			}
		}
		System.out.println("简单选择排序交换位置："+count+"次！");
	}
	/**
	 * 直接插入排序
	 *  外层循环，i从小到大； temp = array[i]
	 *  内层循环，j从外层下标i-1开始,递减--；
	 *  内层循环找到比temp小的元素array[j]，把该元素下标位置+1，array[j+1] = array[j];
	 *  内层循环一出现temp大的元素array[j],跳出循环，记录j值
	 *  把temp (array[i])的值赋给 array[j+1]
	 *   
	 *  明显的比 简单选择排序少了，交换位置的操作。 
	 * @param args
	 */
	public void insertSort(int [] array) {
		for(int i =1;i<array.length;i++) {
			int temp = array[i];//新遍历的值，需要插入到前面的数组
			int j = 0;
			//从最大的开始比较
			for(j = i-1;j>-1;j--) {
				if(array[j]>temp) {
					//将大于temp的数往后移一步，
					array[j+1] = array[j];
				}else {
					//出循环的时候，j--执行过一次,所以在外
					//交换位置时，需要+1；
					break;
				}
				System.out.println("内j="+j);
			}
			System.out.println("外j="+j);
			array[j+1] = temp;
		}
	}
	/**
	 * 二分法插入排序:不稳定排序
	 *  外层循环 i ，从array.length到小；temp = array[i];
	 *  left = 0 ; right = i-1；
	 *  内层循环 while(left <= right){
	 *  	每次 temp与 array[mid] 元素比较  mid = (left+right)/2
	 *  	重新left right 赋值；
	 *  }
	 *  外层循环就 j= i-1; j>left j递减{
	 *  	大于left下标对应值  都位置向后移动-一位；
	 *  }
	 *  
	 *  如果 left != i
	 *  array[left] = temp;
	 *  
	 * 
	 * @param args
	 */
	public void binaryInsertSort(int [] array) {
		for(int i =1;i<array.length;i++) {
			int temp = array[i];
			int left = 0;
			int right  = i-1;
			int mid = 0;
			while(left <= right) {
				mid = (left + right)/2;
				if(temp<array[mid]) {
					right = mid -1;
				}else {
					left = mid +1;
				}
			}
			for(int j =i-1;j>=left;j--) {
				//temp后的位置全部后移动一位
				array[j+1] = array[j];
			}
			if(left != i) {
				array[left] = temp;
			}
		}
	}
	/**
	 * 希尔排序--不稳定排序:直到最后一次循环走完，才能确定最终的结果
	 * @param array
	 */
	public void HeerSort(int [] array) {
		//每次移动的增量为 length/2;
		for(int gap= array.length/2;gap>0;gap /=2) {
			//根据增量 分成不同的组，各组元素之间进行插入排序
			for(int i =gap;i<array.length;i++) {
				//记录当前元素的值，用于交换（最基础的A B C三个杯子，把A中水换到B杯 ）
				int temp = array[i];
				//j 用于该元素与 同组元素比较时 下标迭代
				int j = i;
				if(temp<array[i-gap]) {
					/**
					 * 符合if条件,则whlie 至少执行一次，交换位置
					 * 交换后 j = j-gap ，继续与同组前一个元素比较；
					 */
					while(j-gap>=0 && array[j]<array[j-gap]) {
						array[j] = array[j-gap];
						j -= gap;
					}
					//跳出循环时， j已经减去gap
					/**
					 *  temp = a;
					 *  a = b;
					 *  b = temp;
					 *  
					 *  int temp = array[i];
					 *  array[j] = array[j-gap];
					 *  跳出循环时， j已经减去gap
					 *  array[j] = temp; 
					 */
					array[j] = temp; 
				}
			}
		}
	}
	
	public static void main(String[] args) {
		JavaAlgorithm javasort = new JavaAlgorithm();
		int [] array = new  int[] {12,-1,3,54,22,667,57,67,-2};
//		javasort.chooseAlgorithm(array);
//		javasort.bubbleSort(array1);
//		javasort.insertSort(array);
//		javasort.binaryInsertSort(array);
//		for(int mun :array){
//			System.out.println("shu:"+mun);
//		}
		javasort.HeerSort(array);
		for(int mun :array){
			System.out.println("shu1:"+mun);
		}
	}
}