两种二分查找

给定按照非递减序的数组和关键字key，返回key在给定数组中的下标，若不存在则返回-1。

二分查找的关键是控制好下标low和high，以及返回值。最后要返回的是下标low的值

比如给定排好序的数组nums[]和要查找的关键字key，返回关键字key在数组中的下标。假设要查找的关键字在数组中存在。这两个方法返回的都是数组中与关键字相等的元素的第一个下标，比如[5,6,6,7,8]关键字是6，则返回6的第一个下标1.

 public int binarySearch1(int nums[],int key){  //优先用这个。
		 	int high = nums.length-1;
	        int low = 0;
	        int mid = 0;
	        while(low<high){//注意1对应注意2
	        	mid=low + (high-low)/2;  
	        	if(nums[mid]<key){
	        		low = mid+1;
	        	}else {
	        		high = mid; //注意2
	        	}
	        }
	        return low;//low出循环的时候肯定是在[0,high],都是数组的正常合法的下标。
	 }
	
	 public int binarySearch2(int nums[],int key){
		 	int high = nums.length-1;
	        int low = 0;
	        int mid = 0;
	        while(low<=high){//注意3对应注意4
	        	mid=low + (high-low)/2;  
	        	if(nums[mid]<key){
	        		low = mid+1;
	        	}else {
	        		high = mid-1;//注意4
	        	}
	        }
	        return low;//<span style="font-family: Arial, Helvetica, sans-serif;">low出循环的时候肯定是在[0,high],都是数组的正常合法的下标。</span>

	 }

上面的是假设关键字存在，关键字不存在时，返回-1.

/*如果关键字在数组中存在则返回第一次出现的下标，不存在的时候则返回-1*/
	 public int binarySearch11(int nums[],int key){//返回的是与关键字相等的元素下界,即如果有多个数组元素与关键字相等的时候，返回的是第一个元素的下标。
		 	int high = nums.length-1;
	        int low = 0;
	        int mid = 0;
	        while(low<high){ //当数组中不存在的时候且比数组元素都大的时候返回的下标是len
	        	mid=low + (high-low)/2; 
	        	System.out.println("mid = "+mid);
	        	if(nums[mid]<key){
	        		low = mid+1;
	        	}else {
	        		high = mid;
	        	}
	        }
	        return nums[low]==key?low:-1;
	 }

当想返回元素上界的时候：

int upperbound(int[] nums, int target) { // 找关键字在数组中出现的上界
		int high = nums.length - 1;
		int low = 0;
		int mid = low + (high - low + 1) / 2;
		while (low <high) {
			mid = low + (high - low + 1) / 2;
			if (nums[mid] <= target) {
				low = mid ;
			} else {
				high = mid - 1;
			}
		}
		
		 return nums[low] == target ? low : -1;    //这样就避免了溢出
	}

存在返回上界，不存在返回-1.比如[5,6,6,7,8]关键字是6，返回的是下标2.