二分法查找，冒泡排序，快速排序 简单示例

二分法查找：

/**
	 * 二分法查找 从一个有序数组(如升序)中找到值为key元素
	 * 
	 * @param key 要查找的值
	 * @param array 目标数组（有序）
	 * @return 如果找到目标元素，则返回其在数组中的索引，否则返回-1
	 */
	public static int find(int key, int[] array) {
		int low = 0;
		int high = array.length - 1;
		while (low <= high) {
			int mid = low + (high - low) / 2;
			if (array[mid] > key) {
				high = mid - 1;
			} else if (array[mid] < key) {
				low = mid + 1;
			} else {
				return mid;
			}
		}
		return -1;
	}

冒泡排序:

    /**
	  * 冒泡排序
	  */
	 public static void bubbleSort1(int[] arr) {
		 //外层循环,控制循环次数
		 for (int j = 0; j < arr.length; j++) {
			//内层循环,控制每次循环交换数据次数
			 for (int i = 0; i < arr.length-1-j; i++) {
				if(arr[i]>arr[i+1]) {
					int t = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = t;
				}
			}
		} 
	 }

快速排序：

private static void quickSort(int[] arr, int low, int high) {
		if (low < high) {
			// 分区操作，将一个数组分成两个分区，返回分区界限索引
			int index = partition(arr, low, high);
			// 对左分区进行快排
			quickSort(arr, low, index - 1);
			// 对右分区进行快排
			quickSort(arr, index + 1, high);
		}
	}

	private static int partition(int[] arr, int low, int high) {
		// 制定左指针i和右指针j
		int i = low;
		int j = high;
		// 将第一个数作为基准值，挖坑
		int x = arr[low];
		// 循环执行分区操作
		while (i < j) {
			// 1.从右向左移动j，找到第一个小于基准值的值arr[j]
			while (arr[j] >= x && i < j) {
				j--;
			}
			// 2.将右侧找到小于基准数的值加入到左边的坑的位置，左指针向中间移动一个位置i++
			if (i < j) {
				arr[i] = arr[j];
				i++;
			}
			// 3.从左向右移动i，找到第一个大于等于基准值的值arr[i]
			while (arr[i] < x && i < j) {
				i++;
			}
			// 4.将左侧找到的大于等于基准值的值加入到右边的坑中，右指针向中间移动一个位置j--
			if (i < j) {
				arr[j] = arr[i];
				j--;
			}
		}
		// 使用基准值填坑，基准值的最终位置
		arr[i] = x;
		// 返回基准值的位置索引
		return i;
	}

	public static void quickSort(int[] arr) {
		//
		int low = 0;
		int high = arr.length - 1;
		quickSort(arr, low, high);
	}