冒泡排序与二分搜索法总结

1. 常见的数组排序

常见的数组排序:

1：冒泡排序

2：插入排序

3：选择排序

4：快速排序（sort()排序）

2. 冒泡排序

冒泡排序：
步骤：
1:两两做大于比较，大的往后移，小的往前移,把最大的值找出来，放在倒数第1位,这个时候，我们数组划分为2部分，排好序是一部分，未排序的是一部分
2:两两做大于比较，大的往后移，小的往前移,把第二大的值找出来，放在倒数第2位,这个时候，我们数组划分为2部分，排好序是一部分，未排序的是一部分
3：依次类推，直到把所有的数字都按照从小到大的顺序，排列

 冒泡优化
 1：把中间变量从小循环的里面，拿出来放在最大循环的外面声明，可以减少声明次数：    
 2：每排序出一个元素后，后面的排序，就可以减少一次  
    第1大的数 排序7 次
    第2大的数 排序6 次
    第3大的数 排序5次
    以此类推
    第8大数    排序0次
 3:针对数组本身就是有序的 

public static void main(String[] args) {
	int[] s = {100,56,88,99,47,65,12,10} ;//原数组 乱序
	//int[] s = {1,2,3,4,5,6,7,8} ;//原数组 乱序
	int count = 0;
	int temp = 0; //中间变量，存放需要交换元素的变量
		
	//外层循环控制元素的排序次数
	for(int j=1;j<s.length;j++){
		boolean flag = true;  //表示假如数组是有序的
		//里层循环控制元素的交换次数，交换次数呈递减规律
		for(int i = 0;i<s.length-j;i++){
			count++;
			//如果前一个元素比后一个元素大
			if(s[i]>s[i+1]){
			//如果第一个元素比第二个元素大，交换位置
				temp = s[i];
				s[i] = s[i+1];
				s[i+1] = temp;
				flag = false; //给数组一个标记
				}
			}
			//如果flag还为true，代表这个数组本身就是有序的
			if(flag){
			    //后面的循环就不需要了
		    	break;
			}
			
		}
		System.out.println(count);
		System.out.println(Arrays.toString(s));

3. 二分搜索法

• 二分搜索法（折半查找）前提是这个数组必须是有序的
• Arrays.binarySearch()
• 注意：二分搜索法：根据元素查找下标
• 找到返回当前元素的下标，没有找到返回负数

public static void myBinarySearch(int[] arr,int ele){
	//确保数组有序
	Arrays.sort(arr);
	//int[] arr = {-10,1,10,20,45,56,88}; 
	//定义开始和结尾的2个下标
	int start = 0;
	int end = arr.length;
	int index =-1;
	//保证开头下标不能超过结尾下标，否则数组就会越界
	int count = 0;
	while(start<=end){
		count++;
		int  mid = (start+end)>>>1; //折半点
		//如果目标元素和中间元素相等
		if(arr[mid]==ele){
			//把中间元素的下标赋值给index，代表找到这个元素的下标
			index = mid;
			//后面就不用比较了
			break;
			//如果目标元素比中间元素的值大
		}else if(ele>arr[mid]){
			//去数组的右边来找 并且，start变成mid+1的值，end值不变
			start = mid+1;
			//如果目标元素比中间元素的值小
		}else{
			//去数组的右边来找 并且，end变成mid-1的值，start值不变
			end = mid-1;
		}
	}
	System.out.println(count);
	if(index!=-1){
		System.out.println("元素:"+ele+"的下标是:"+index);
	}else{
		System.out.println("不存在此元素");
	}
}