JAVA_day_06_排序、查找、传参

1 排序

1.1冒泡排序

package _01_ArrayUse;

import java.util.Arrays;

/**
 * 排序  让保存的规则按一定的规则进行存储 
 		(十大排序算法)
  * 冒泡排序 : 
		1 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 
		2 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
		3 针对所有的元素重复以上的步骤，除了最后一个。 
		4 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
 * 
 
 * @author 16200
 *2022年1月5日上午10:04:50
 */
public class _01_ArrayBubbleSort {

	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);
		
		Arrays.sort(arr);//API排序,只能做到升序,API:应用程序接口,别人写好的直接用
		for (int i = 0 ; i< arr.length;i++){
			System.out.print(arr[i]);
		}
	}
	public static void bubbleSort(int[] arr){ 
		// 要小于长度-1 ,比如有5个元素,只需要比较4次即可
		for (int j = 0; j < arr.length-1; j++){
			//-j是因为每次外层循环每执行完一次,就会找到一个最大的到最后
			// 我们没有必要在和后面比较大的元素进行比较,不-j也可以,就是运行次数会增多
			for (int i = 0 ; i< arr.length-1- j;i++){
				// 升序是 >  降序 是 < 
				if (arr[i] > arr[i+1]){
					int temp = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
				}
			}
		}
	}
}

1.2 选择排序

package _01_ArrayUse;
/**
 * 选择排序
 		1 每次把最小的放左边
 			拿出第一个,假设最小,然后与后面的元素比较,记录最小的,如果比第一个还小,则与第一个换位
 		2 重复执行这一步骤,直到后面没有其他元素
 * @author 16200
 *2022年1月5日上午11:43:23
 */
public class _02_ArraySelectSort {

	public static void main(String[] args) {
		int[] arr = {2,6,4,3,1};
//		selectSort(arr);
		sort(arr);
		for (int i = 0 ; i< arr.length;i++){
			System.out.print(arr[i]);
		}
	}
	public static void selectSort(int[] arr){
		//
		for (int current = 0;current < arr.length-1;current++){
			//假设当前这个元素是最小的
			int min = current;
			//current+1 是因为没必要和自己比较
			for( int i = current+ 1;i < arr.length;i++){
				//判断是否有其他元素比min还小
				if (arr[min] > arr[i]){
					//如果有 把这个数给min
					min = i;
				}
			}
			//判断 min是否于current相同
			if(min != current){
				//不相同则把min和current换位
				int temp = arr[current];
				arr[current] = arr[min];
				arr[min] = temp;
			}
		}
	}
	public static void sort(int[] a){
		for(int i = 0; i < a.length; i++){
			//假设第一个最小,并定义一个index用于记录位置
			int index = i;
			int min = a[i];
			//循环比较
			for (int j = i + 1;j < a.length ;j ++){
			//如果当前位比最小值小,把当前位的值给min
				if(a[j]<min){
					min = a[j];
					index = j;
				}
			}//把当前位和最小值位互换
			a[index] = a[i];
			a[i] = min;
		}
		}
}

2 查找

2.1 顺序查找

package _01_ArrayUse;

import java.awt.print.Printable;

/**
 * 查找数据 , 比如在一堆数据中 要找到某一个并返回其索引,未找到返回-1
 * 
 * 返回值为boolean : 真就是true 假就是false
 * 
 * 返回数字 : 比如 返回索引,能找到 就返回索引,找不到就返回-1
 * 
 * 引用类型 : 真 就是对象 , 假 就是null
 *
 * @author 16200
 *2022年1月5日下午2:14:23
 */
public class _03_BinarySearch {

	public static void main(String[] args) {
		//数据
		int[] arr = {1,3,4,5,6,7,9,15,17,19,38,41,52,63,73,78};
		//要查找的数据
		int target = 9;
		System.out.println(search(arr, target));
		System.out.println(binarySearch(arr, target));
	}
	/**
	 *顺序查找 , 遍历 , 用所有数据 挨个和目标数据进行比较
	 * 
	 * 如果数据在前面,相对快一些,但是随机查找,效率偏低
	 * @param arr
	 * @param target
	 * @return
	 */
	public static int search(int[] arr,int target){ 	
		for(int i = 0;i < arr.length;i++){
			if (arr[i] == target){
				return i;
			}
		}
		return -1;
	}
	
	
	
}

2.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) {
			//
			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;
	}

3 传参

package _01_ArrayUse;

public class _04_Arg {
	public static void main(String[] args) {
		m1(1);
		m2(new int[] { 1, 2, 3, 4 });
		m2(new int[] { 1 });

		// 优化了调用
		m3(1, 2, 3, 4);
		m3(1);
		m3(new int[] { 1, 2, 3, 4 });
	}
	
	//接收单个int类型
	public static void m1(int i) {
		
	}
	
	//接收int数组(多个int类型)
	public static void m2(int[] arr) {
		
	}
	
	//可变长参数,就是数组,只不过调用处传参方便一些
	//注意 可变参数这种写法,一个参数列表中只能有一个,并且必须是最后一个参数
	public static void m3(int... a) {
		for (int i = 0; i < a.length; i++) {
			System.out.println(a[i]);
		}
	}
}