数组的冒泡排序和二分法查找

数组冒泡排序

public class ArrayTest01 {
	public static void main(String[] args) {
	int[] arr = {3, 5, 1, 7, 6, 2, 4};
		// 外侧循环：用于控制比较的躺数
		for(int i = 0; i < arr.length - 1; i++) {
			// 在每一趟判断以前，先假设本趟排序已经完成
			boolean flag = true;
			// 内侧循环：用于控制每一趟相邻元素比较的次数
			for(int j = 0; j < arr.length - i - 1; j++) {
				// 相邻两个元素作比较，若是前一个大于后一个，则交换位置
				if(arr[j] > arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
					// 进入此处，证实本趟排序还未完成，因此推翻假设
					flag = false;
				}
			}
			System.out.print("第" + (i+1) + "次排序：");
			for(int value : arr) {
				System.out.print(value + " ");
			}
			System.out.println();
			// 最后判断flag标记的值，从而肯定排序是否已经完成
			if(flag) {
				break; // 跳出外侧循环
			}
		}
		
		System.out.print("排序完成：");
		for(int value : arr) {
			System.out.print(value + " ");
		}
    }
}

冒泡排序

工做原理：重复地走访过要排序的数列，一次比较两个元素，若是他们的顺序错误就把他们交换过来。走访数列的工做是重复地进行直到没有再须要交换，也就是说该数列已经排序完成。

这个算法的名字由来是由于越大的元素会经由交换慢慢“浮”到数列的顶端，故名。

ublic class ArrayTest02 {
	public static void main(String[] args) {
		int[] arr = {3, 5, 1, 7, 6, 2, 4};
		sort(arr);
		System.out.print("排序完成：");
		for(int value : arr) {
			System.out.print(value + " ");
		}
	}
	
	/**
	 * 冒泡排序（升序）
	 * @param arr 须要排序的数组
	 */
	public static void sort(int[] arr) {
		// 外侧循环：用于控制比较的躺数
		for(int i = 0; i < arr.length - 1; i++) {
			// 在每一趟判断以前，先假设本趟排序已经完成
			boolean flag = true;
			// 内侧循环：用于控制每一趟相邻元素比较的次数
			for(int j = 0; j < arr.length - i - 1; j++) {
				// 相邻两个元素作比较，若是前一个大于后一个，则交换位置
				if(arr[j] > arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
					// 进入此处，证实本趟排序还未完成，因此推翻假设
					flag = false;
				}
			}
			// 最后判断flag标记的值，从而肯定排序是否已经完成
			if(flag) {
				break; // 跳出外侧循环
			}
		}
	}
}

二分法查找

二分查找又称折半查找

优势：比较次数少，查找速度快，平均性能好；

缺点：是要求待查表为有序表，且插入删除困难。

所以，折半查找方法适用于不常常变更而查找频繁的有序列表。

前提：必须是有序的数组。

例题：获取元素12在数组{0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20}中的索引。

public class ArrayTest03 {
	public static void main(String[] args) {
		int[] arr = {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20};
		// 定义须要查找的元素
		int value = 12;
		int index = binarySearch(arr, value);
		System.out.println(index);
	}
	/**
	 * 折半查找
	 * @param arr 须要查找的数组
	 * @param value 须要查找的元素
	 * @return 返回查找到的元素索引，若是没找到则返回-1
	 */
	public static int binarySearch(int[] arr, int value) {
		// 定义三个变量
		int min = 0, max = arr.length - 1, mid;
		// 经过死循环执行二分查找
		while (true) {
			// 更新mid的值
			mid = (min + max) / 2;
			// 判断arr[mid]和value的值
			if (arr[mid] > value) {
				max = mid - 1;
			} else if (arr[mid] < value) {
				min = mid + 1;
			} else {
				return mid;
			}
			// 若是max小于min，则证实value在数组中不存在
			if (max < min) {
				return -1;
			}
		}
	}
}