java选择排序，冒泡排序分析，附带二分法查找

冒泡排序和选择排序是排序算法中比较简单和容易实现的算法，也是面试当中经常被考到的题目，所以是必须掌握的！

假设将数组 int[] arr = { 10, 7,11, 3, 2, 9 }; 升序排列

选择排序的思想是：从左到右依次遍历，每次遍历确定一个位置，所有遍历的元素都和这个位置上的数比较

        如上数组，首先10 和 7比较，10比7大，交换位置，这时 7是数组的第一个 ，然后用 7 和 11 比较，7 比 11小，不交换， 然后，7 和 3 比较， 7 比 3 大，交换位置，3是数组的第一个，然后 3 和 比较 ，3 比 2 大，交换位置，2是数组第一个 ，然后 2 和 9 比较 ，2 比 9 大，不交换 ，此时 外层 第一个遍历完成，2排在了数组的第一位，此时的数组是 {2，10，11，7，3，9} ，然后再从第二个元素遍历，10 和 11比较，不换位置，10和7比较 ，换位置，7和 3比较，还位置，3和9比较 换位置，此时的数组是    { 2，3，11，10，7，9}  ，这样一次类推下去，最后形成数组 {2，3，7，9，10，11} ；

	/*
	 * 选择排序
	 */
	@Test
	public void selectSort() {
		int[] arr = { 10, 7,11, 3, 2, 9};
		for (int i = 0; i < arr.length - 1; i++) { // 循环length-1次, 每次选择一个数放在最前面
			for (int j = i + 1; j < arr.length; j++) {// 从0循环到length-1, 遍历每一个元素
				if (arr[i] < arr[j]) { // 用每一个元素和0号元素(第一个)去比较, 如果比第一个小
					int one = arr[i];
					arr[i] = arr[j];
					arr[j] = one;
				}
			}
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]);
		}
	}

和上面一样 假设将数组 int[] arr = { 10, 7,11, 3, 2, 9  }; 升序排列

冒泡排序的思想是：每次循环排序中，通过相邻元素的比较交换将最大值移动到右侧；意思就是 ，元素1和元素2比较，然后元素2和元素3比较，再元素3和元素4比较。。。

     如上数组，首先外层第一次循环后 内层循环 先比较 10 和 7 ，10 比 7大，交换位置，然后此时10 和 11比较，10比 11 小，不交换，然后 11 和 3比较 ，交换位置，然后 11和 2 比较，交换位置，然后 11 和 9比较 ，交换位置，外层第一次循环后，数组形式是{7，10，3，2，9，11}，然后外层第二次循环，7和 10比较，7比10小，不交换，然后，10和 3 比较，交换位置，然后 10和 2比较，交换位置，然后 10和9 比较，交换位置，此时，因为最后一个元素已经确定为最大数，所以不用比较，因此第二层外层循环结束后，数组形式是：{7，3，2，9，10，11}，一次类推，结果是：{2，3，7，9，10，11} ；

	/**
	 * 冒泡排序
	 */
	@Test
	public void bubbleSort() {
		int[] arr = { 10, 7,11, 3, 2, 9 };
		for (int i = 0; i < arr.length - 1; i++) { // 循环length-1次, 每次冒泡一个数到最后
			for (int j = 0; j < arr.length - 1 - i; j++) { // 每次从第一个开始, 向后遍历.
								       // 第一次到倒数第二个,
								       // 第二次到倒数第三个
				if (arr[j] > arr[j + 1]) { // 用每一个数和后面一个比较, 如果大就交换
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}

public class Dichotomy  {
	public static void main(String[] args) {
		// 定义一个数组
		int nums[] = { 1, 3, 6, 8, 9, 10, 12, 18, 20, 33, 34 };
		// 欲查询的数字
		int num = 34;
		// 输出num在nums中的索引
		System.out.println("二分法查看数组中某数的索引为：" + dichotomy(nums, num));
	}

	/**
	 * 二分法查找
	 * 
	 * @param nums
	 *            数组
	 * @param num
	 *            查找的数
	 * @return 返回num索引，如果不存在返回-1
	 */
	public static int dichotomy(int[] nums, int num) {
		// 数组长度必须大于零
		if (nums != null && nums.length > 0) {
			// 开始索引
			int start = 0;
			// 结束索引
			int end = nums.length - 1;
			// 中间索引
			int center = (start + end) / 2;
			// 开始索引不能大于结束索引
			while (start <= end) {
				// 取中间索引值比较，如果相同，返回该索引
				if (num == nums[center]) {
					return center;
				}
				// 如果值在center右边或左边，重新定位start或end，重新计算center值
				if (num > nums[center]) {
					start = center + 1;
				}
				if (num < nums[center]) {
					end = center - 1;
				}
				center = (start + end) / 2;
			}
		}
		return -1;
	}
}