经典排序及二分查找法

经典排序

1冒泡排序

冒泡排序思想:
冒泡排冒泡排序思想:通过外层循环控制所要比较的轮数,内层循环控制每轮所要比较的次数,每轮都将数组中的元素j和它相邻的元素j+1进行比较,若果arr[j] < arr[j + j],则将两个元素位置进行交换,就如同冒泡一样,大的泡泡会不断的向上浮.

public static void bubbleSort(int[] arr) {
	// 定义一个空碗变量
	int temp;
	// 外行循环控制要比较几轮
	for (int i = 0; i < arr.length; i++) {
		// 内循环控制每轮要比较的次数
		for (int j = 0; j < arr.length - 1 - i; j++) {
			if (arr[j] > arr[j + 1]) {
				temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

2. 选择排序

选择排序思想:
每一次循环,从中选出最小值或者最大值,将最小值或最大值放在数组的0索引位置,后续的比较就可以忽略已经筛选出来的最小值或者最大值.

public static void selectSort(int[] arr) {
	int temp = 0;
	// 外层控制轮数,因为最后一轮不许需要再进行比较了,所以arr.length - 1
	for (int i = 0; i < arr.length - 1; i++) {
		// 内层控制每轮比较次数
		for (int j = i + 1; j < arr.length; j++) {
			if (arr[i] > arr[j]) {
				temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
	}
}

3. 快速排序

快速排序想:
1. 先设立一个基准值arrbenchmark,一般会将数组的0索引位置的值设为基准值.
2. 从数组的左侧和数组的右侧分别开始和基准值进行比较,设立一个i值(为0索引)每次满足循环条件(arr[i] <= arr[benchmark])的时候进行i++递增,再设立一个j值(数组最大索引)每次满足循环条件(arr[j] >= arr[benchmark])的时候进行j–递减.
3. 当右侧的值(arr[i])大于基准值(arr[benchmark])的时候,跳出当前循环,当左侧的值(arr[j])小于基准值(arr[benchmark])的时候,跳出当前循环,让后将左侧和右侧这两个跳出循环的值进行交换,以此方式进行比较,直到i == j 的时候,将基准值和arr[i]进行交换位置,这样第一遍循环结束的时候,基准值arr[benchma]左侧的全部小于基准值,右侧的值全部大于基准值.
4. 利用递归思想,再分别将基准值左侧和基准值右侧的数组进行排序,直到整个数组arr排序完毕.

public static void quickSort(int[] arr, int low, int high) {
	if (low > high) {
		return;
	}
	int benchmark = arr[low];
	int i = low;
	int j = high;
	while (i < j) {
		// 先从右侧开始找比基准值小的数,如果找到,跳出当前训话
		while (arr[j] >= benchmark && i < j) {
			j--;
		}
		// 再从左侧开始找比基准值大的数,如果找到跳出当前循环
		while (arr[i] <= benchmark && i < j) {
			i++;
		}
		// 将比基准值大的和比基准值小的元素的位置进行交换
		if (i < j) {
			int temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
		// 将基准值和 i == j 的位置进行交换
		arr[low] = arr[i];
		arr[i] = benchmark;
		//利用递归思想,将基准值左右两侧继续排序,直到排序完成
		quickSort(arr, low, j - 1);
		quickSort(arr, j + 1, high);
	}
}

4. 二分查找(折半查找)

二分查找思想:
1. 该数组中的元素必须是有序的.
2. 首先定义三个值,最大索引max,最小索引min,中间索引mid.
3. 进行判断,如果该元素的值大于中间索引的值(arr[mid]),将最小索引改为min = mid + 1.
4. 如果该元素的值小于中间索引值(arr[mid]),将最大索引值改为 max = mid - 1.
5. 1.如果该值的索引等于中间索引mid,直接返回mid
6. 如果本次循环没有找到该值的索引,将mid重新赋值,继续查找,当循环结束也没有找到该值的索引时,进行return.

public static int binarySearch(int[] arr, int number) {
	// 创建三个角标,最大值角标,最小值角标,中间值角标
	int min = 0;
	int max = arr.length - 1;
	int mid = (min + max) / 2;
	// 将所要查找的值的角标筛选出来
	while (min <= max) {
		// 当所要查找的值大于arr[mid]时,重新定义最小值角标
		if (number > arr[mid]) {
			min = mid + 1;
		// 当所要查找的值小于arr[mid]时,重新定义最大值角标
		} else if (number < arr[mid]) {
			max = mid - 1;
		// 所要查找的值的索引为mid时候,直接返回所要查找的值的角标
		} else {
			return mid;
		}
	// 因为最小索引min和最大索引max被重新定义,中间索引也要被重新定义
		mid = (max + min) / 2;
	}
	// 当查询不到值value时候,直接返回-1
	return -1;
}