二分查找法、冒泡排序、选择排序、插入排序的Java代码实现（学习笔记）

一、二分查找法

 
  /**
	 * 二分查找法
     * 特点：前提是顺序存储结构（数组），并且内部元素有序
	 * 时间复杂度： log2(n)
	 * @param arr
	 * @param searchKey
	 * @return 返回目标值在数组中的索引值， -1 表示未找到
	 */
	public static int binarySearch(int[] arr, int searchKey) {

		// 空数组和1个元素的数组不需要排序
		if (arr == null || arr.length == 0) {
			return -1;
		}

		int low = 0;
		int high = arr.length - 1;
		int mid = 0;
		while (low <= high) {			
			//找到中间值
			mid = (low + high) / 2;			
			//找到目标值，直接返回目标值的索引
			if (arr[mid] == searchKey) {
				return mid;
			}
			//如果中间值比目标值小，需要改变low的值
			if (arr[mid] < searchKey) {
				low = mid + 1;
			}
			//如果中间值比目标值大，需要改变high的值
			if (arr[mid] > searchKey) {
				high = mid - 1;
			}
		}
		return -1;

	}

 

二、冒泡排序

/**
	 * 冒泡排序 
	 * 特点：每次循环中最大的值向右靠,好比气泡一样。
	 * 时间复杂度： O(n)2
	 * @param arr
	 * @return 返回排序后的数组
	 */
	public static int[] bubbleSort(int[] arr) {

		// 空数组和1个元素的数组不需要排序
		if (arr == null || arr.length < 2) {
			return arr;
		}

		boolean isSwap = false; //用于判断初始数组是否有序，小小优化一下
		for (int i = arr.length - 1; i > 0; i--) {
			int temp = 0;
			for (int j = 0; j < i; j++) {
				// 左边比右边值大，则需要进行交换
				if (arr[j] > arr[j + 1]) {
					temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
					isSwap = true;
				}
			}
			// 如果没有过交换，表示该数组有序
			if (!isSwap) {
				break;
			}
		}
		return arr;
	}

 

三、选择排序

/**
	 * 选择排序（冒泡的升级版）
	 *  特点：每次循环中最小的值向左靠拢，相比冒泡，降低了交换次数 
	 *  时间复杂度： O(n)2
	 * @param arr
	 * @return 返回排序后的数组
	 */
	public static int[] selectSort(int[] arr) {

		// 空数组和1个元素的数组不需要排序
		if (arr == null || arr.length < 2) {
			return arr;
		}

		for (int i = 0; i < arr.length - 1; i++) {
			int min = i; // 记录每次循环中最小值的位置
			int temp = 0; // 用于交换的临时值
			for (int j = i + 1; j < arr.length; j++) {
				// 记录本次循环中最小值的索引
				if (arr[min] < arr[j]) {
					min = j;
				}
			}
			// 如果 i索引值不是最小，则需要进行交换位置
			if (i != min) {
				temp = arr[i];
				arr[i] = arr[min];
				arr[min] = temp;
			}
		}

		return arr;
	}

四、插入排序

/**
	 * 插入排序
	 * 特点：复制的次数大于比较的次数，逆序和冒泡一样，
	 *      局部有序的数组，该算法比较有优势，可以用于复杂算法排序的后期阶段
	 * 时间复杂度： 随机顺序的情况下是O(n)2，基本有序的情况下是O(n)
	 * @param arr
	 * @return 返回排序后的数组
	 */
	public static int[] insertSort(int[] arr) {

                 // 空数组和1个元素的数组不需要排序
		if (arr == null || arr.length < 2) {
			return arr;
		}	      
		int in = 0;
		int out = 0; 
		for( out = 1; out < arr.length; out++) {
			int temp = arr[out];
			in = out;
			//找到插入元素的正确位置，正确位置后面的每一个元素都需要后移，需要给待插入元素腾出空间
			while(in > 0 && arr[in -1] > temp) {
				arr[in] = arr[in -1];
				--in;
			}
			//元素放入正确的位置
			arr[in] = temp;
		}
		return arr;
	}

——————————————————————————————————————————————

万丈高楼平地起，地基必须得夯实！

本人菜鸟一枚，有错误的地方，欢迎大神们不吝赐教，不喜勿喷！！！