数组排序

1，冒泡排序：

	public static void main(String[] args) {
		int[] arr = { 29, 13, 33, 10, 27, 84, 2, 30, 19, 40 };

		/**
		 * 冒泡排序： 两两比较，较大的就往后移动
		 * 外层循环完毕，大数就固定一位(右--->左)
		 * 比较的时间级别为O(N^2) (N-1)+(N-2)+...+1 = N(N-1)/2 
		 * 交换的时间级别为O(N^2) 平均交换 (N-1)/2 + (N-2)/2 +...+1 
		 */
		for (int out = arr.length - 1; out > 0; out--) {
			for (int in = 0; in < out; in++) {
				if (arr[in] > arr[in + 1]) {
					int temp = arr[in];
					arr[in] = arr[in + 1];
					arr[in + 1] = temp;
				}
			}
		}
		for (int a : arr) {
			System.out.println(a);
		}

	}

2，选择排序：

public static void main(String[] args) {
		int[] arr = {29,13,33,10,27,84,2,30,19,40};
	
		int min;
		/**
		 * 选择排序：
		 * min记录最小数的位置
		 * 内层循环完毕，找出最小数arr[min]
		 * arr[min]与arr[out]交换，这样外层循环完一次，就确定了一个位置（左-->右）
		 * 比较的时间级别任然是O(N^2)
		 * 交换的时间级别变成了O(N)
		 * 当N较小时候，交换时间级别大于时间比较级别时候，选择排序 比冒泡排序更好
		 */
		for(int out=0;out<arr.length-1;out++){
				min = out;
				for(int in = out+1;in <arr.length;in++){
					if(arr[in]<arr[min]){
						min =in;
					}
				}
				int temp = arr[out];
				arr[out] = arr[min];
				arr[min] =temp;
		}
		for(int a : arr){
			System.out.println(a);
		}
	}

3，插入排序

public static void main(String[] args) {
		
		int[] arr = { 29, 13, 33, 10, 27, 84, 2, 30, 19, 40 };
		int out;
		int in;		
		/**
		 * 插入排序
		 * 局部有序，内层循环完毕，标记数字的左边局部有序，标记右移一位，再将标记的数字跟左边有序的数字依次比较(右-->左)
		 * 找到合适的位置插入
		 */
		for( out =1;out<arr.length;out++){
			//被标记的数字
			int temp =arr[out];
			in =out ;
			//下面的for循环跟while循环都可以实现目标
			for(;;){
				if(in >0 && arr[in-1] > temp ){
					arr[in] = arr[in-1];
					in--;
				}else{
					break;
				}
				
			}
		/*	while(in>0 && arr[in-1] > temp){
				arr[in] = arr[in-1];
				in--;//只有标记位数字小于左边排好序的其中之一时候，才in--
			}*/
			//合适位置就是当前的in位，将标记的数字插入
			arr[in] = temp;
		}
		for(int a : arr){
			System.out.println(a);
		}
	}

插入排序的时间复杂度也是O(N^2),但是复制和交换时间的耗费不同，所以相对于随机数据下，其效率是冒泡排序的2倍，比选择排序快一些。如果对于基本有序的数据来说，内层循环总是假，所以变成外层循环的简单语句，执行N-1次，时间复杂度O(N),所以，对于基本有序的数据，简单高效。对于逆序排列的数据，每次比较，移动都会执行，所以插入排序不必冒泡快。