排序算法

**冒泡排序
9 8 10 7 6 0 11
7个数据循环六次。

		第一次循环：
		8 9 10 7 6 0 11（第1次比较：交换）
		8 9 10 7 6 0 11（第2次比较：不交换）
		8 9 7 10 6 0 11（第3次比较：交换）
		8 9 7 6 10 0 11（第4次比较：交换）
		8 9 7 6 0 10 11（第5次比较：交换）
		8 9 7 6 0 10 11（第6次比较：不交换）
		最终冒出的最大数据在右边：11

		第二次循环：
		参与比较的数据：8 9 7 6 0 10 
		8 9 7 6 0 10（第1次比较：不交换）
		8 7 9 6 0 10（第2次比较：交换）
		8 7 6 9 0 10（第3次比较：交换）
		8 7 6 0 9 10（第4次比较：交换）
		8 7 6 0 9 10（第5次比较：不交换）

		第三次循环：
		参与比较的数据：8 7 6 0 9 
		7 8 6 0 9（第1次比较：交换）
		7 6 8 0 9（第2次比较：交换）
		7 6 0 8 9（第3次比较：交换）
		7 6 0 8 9（第4次比较：不交换）

		第四次循环：
		参与比较的数据：7 6 0 8 
		6 7 0 8（第1 次比较：交换）
		6 0 7 8（第2 次比较：交换）
		6 0 7 8（第3 次比较：交换）

		第五次循环：
		参与比较的数据：6 0 7
		0 6 7（第1次比较：交换）
		0 6 7（第2次比较：不交换）

		第六次循环：
		参与比较的数据：0 6
		0 6 （第1次比较：不交换）

package javaCoreTest;

//冒泡排序

public class BubbleSort {

	public static void main(String [] args) {
		int [] arr = {9, 10, 0, 78, 96, 2, 3};
		
		//7条数据循环6次
		for(int i = arr.length - 1; i > 0; i-- ) {
			for(int j = 0; j < i; j++) {
				if(arr[j] > arr[j+1]) {
					int temp;
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		
		for(int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");//0 2 3 9 10 78 96 
		}
		
	}
}

**选择排序
循环一次，然后找出参加比较的这堆数据中最小的，拿着这个最小的值和最前面的数据交换位置。

相对冒泡来说，更加高效

3 1 6 2 5
五个数字，循环四次。

第一次循环
	参与比较的数字：3 1 6 2 5
结果：1 3 6 2 5

第二次循环
参与比较的数字：3 6 2 5
结果：2 6 3 5

第三次循环
参与比较的数字：6 3 5
结果：3 6 5

第四次循环
参与比较的数字：6 5
结果：5 6 

package javaCoreTest;

//选择排序 

public class SelectSort {

	public static void main(String [] args) {
		int [] arr = {3, 1, 6, 2, 5};
		
		for(int i = 0; i < arr.length - 1; i++) {
			int min = i;//假设下标i位置上的元素是最小的
			
			for(int j = i + 1; j < arr.length; j++) {
				if(arr[min] > arr[j]) {
					min = j;//最小元素的下标为j
				}
			}
			
			if(min != i) {
				//arr[i]最前面的元素
				//arr[min]最小的元素
				int temp;
				temp = arr[i];
				arr[i] = arr[min];
				arr[min] = temp;
			}
		}
		
		for(int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");//1 2 3 5 6 
		}
	}
}