2022.01.05_Java学习总结_排序、二分法

1. 注意事项

1 命名 : 
强制规则 : 数字,下划线,大小写字母,美元符号,数字不能开头,不能使用关键字和保留字
非强制规则 :  望文知义,驼峰命名法
变量名和方法名,首字母小写  user,  userService
类名首字母大写 User , UserService
2 注释

2. 排序

排序 就是指让保存的元素按照一定的规则进行排序存储

比如 成绩 按降序排序  ,班级前三名 就取前三个数据就可以

2.1 冒泡排序

* 冒泡排序 : 
		1 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 
		2 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
		3 针对所有的元素重复以上的步骤，除了最后一个。 
		4 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

	public static void main(String[] args) {
		// 2 6 4 3 1
		// 2 6 4 3 1
		// 2 4 6 3 1
		// 2 4 3 6 1
		// 2 4 3 1 6
		// --------
		// 2 4 3 1 6
		// 2 3 4 1 6
		// 2 3 1 4 6
		// -----------
		// 2 3 1 4 6
		// 2 1 3 4 6
		// ---
		// 1 2 3 4 6
		int[] arr = { 2, 6, 4, 3, 1 };
		// bubbleSort(arr);
		// API排序
		Arrays.sort(arr);
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}

	public static void bubbleSort(int[] arr) {
		int count = 0;
		long change = 0;
		// 要小于长度-1 ,比如有5个元素,只需要比较4次即可
		for (int j = 0; j < arr.length - 1; j++) {
			// 要 -1-j , -1上面说了,-j是因为外层循环每执行完一次,就会找到一个最大的放到后面
			// 我们没有必要在和后面比较大的元素进行比较,不-j也可以,就是运行次数会增多
			for (int i = 0; i < arr.length - 1 - j; i++) {
				count++;
				// 升序是 >  降序 是 < 
				if (arr[i] < arr[i + 1]) {
					change++;
					int temp = arr[i];
					arr[i] = arr[i + 1];
					arr[i + 1] = temp;
				}
			}
		}
		System.out.println("冒泡排序完成,执行"+count+"次,换位"+change+"次");
		
	}

2.2 选择排序

* 选择排序 : 
 * 		1 每次把最小的放到左边
 * 			拿出第一个,假设是最小的,然后挨个和后面的比较,如果有比第一个小的,就交换下标
 * 			当比较完一轮之后,已经得到了最小元素的下标,然后放到最前面进行换位即可
 * 		2 重复执行这个步骤,直到当前元素后面 没有其他元素的时候 终止

	public static void main(String[] args) {
		int[] arr = { 2, 6, 4, 3, 1,9,8 };
		selectSort(arr);
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}

	public static void selectSort(int[] arr) {
		int count = 0;
		int change = 0;
		for (int current = 0; current < arr.length - 1; current++) {
			// 假设 当前这个元素 就是最小的
			int min = current;
			// current+1 是因为 自己没有必要和自己比较
			for (int i = current + 1; i < arr.length; i++) {
				count++;
				// 判断是否有其他元素比min还小的
				if (arr[min] < arr[i]) {
					// 如果有 就把这个比min还小的元素下标,赋值给min
					min = i;
					change++;
				}
			}
			// 判断 当前current元素 是否是最小的
			if (min != current) {
				// 如果第一个元素不是最小的,就让该元素和最小的元素换位
				int temp = arr[current];
				arr[current] = arr[min];
				arr[min] = temp;
			}
		}
		System.out.println("选择排序完成,执行"+count+"次,换位"+change+"次");
	}

3. 查找元素

* 查找数据 , 比如在一堆数据中 要找到某一个并返回其索引,未找到返回-1
 * 
 * 返回值为boolean : 真就是true 假就是false
 * 
 * 返回数字 : 比如 返回索引,能找到 就返回索引,找不到就返回-1
 * 
 * 引用类型 : 真 就是对象 , 假 就是null

3.1 顺序查找

*顺序查找，遍历，用所有数据 挨个和目标数据进行比较
*
*如果数据在前面，相对快一些，但是随机查找，效率偏低

public static int search(int[] arr,int target){
	for(int i=0;i<arr.length;i++){
		if(arr[i] == target){
			return i;
		}
	}
}

3.2 二分查找

 * 二分查找,又称为折半查询
	 * 
	 * 1 要求数据必须有序
	 * 
	 * 2 一般用于固定的数据,因为有序,所以添加和删除要麻烦一些,还要考虑元素移位问题
	 * 		
	 * 3 升序和降序都行,只需要更改一下算法判断即可
	 * 
	 * 4 随机查询性能较好
	 * 
	 * 算法实现
	 * 
	 * 1 确定开始和结束还要中间数据
	 * 2 用目标数据 和 中间数据进行比较
	 * 3 如果目标数据等于中间数据,返回中间数据的索引即可
	 * 4 如果目标数据大于中间数据的话,则在后半截继续查找,起始=中间+1,结束不变,再生成中间数据
	 * 5 如果目标数据小于中间数据的话,则取前半截,起始不变,结束=中间-1,再生成中间数据
	 * 6 重复执行以上步骤,如果起始 大于 结束 说明未找到,返回-1

public static int binarySearch(int[] arr, int target) {
		// 1 确定开始和结束还要中间数据
		int startIndex = 0;
		int endIndex = arr.length-1;
		int m = (startIndex+endIndex) /2;
		
		// 循环比较
		while (startIndex <= endIndex) {
			// 3 如果目标数据等于中间数据,返回中间数据的索引即可
			if (target == arr[m]) {
				return m;
			}
			// 如果目标数据大于中间数据的话,则在后半截继续查找,起始=中间+1,结束不变,再生成中间数据
			if (target > arr[m]) {
				startIndex=m+1;
			}else{
				// 如果目标数据小于中间数据的话,则取前半截,起始不变,结束=中间-1,再生成中间数据
				endIndex = m-1;
			}
			// 生成中间数据
			m = (startIndex+endIndex) /2;
		}
		
		// 能执行到这里 , 说明不存在
		return -1;
	}