题目：给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
二分查找 - 力扣
这道题目的前提是数组为有序数组，同时题目还强调数组中无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的，这些都是使用二分法的前提条件，所以在使用二分法的时候需要看看数组是否是有序数组并且数据是没有重复的。
二分法的关键和易错点都是边界，到底是 while(left < right) 还是 while(left <= right)，到底是right = middle呢，还是要right = middle - 1呢？关键在于区间的定义就是不变量。要在二分查找的过程中，保持不变量，就是在while寻找中每一次边界的处理都要坚持根据区间的定义来操作，这就是循环不变量规则。
写二分法，区间的定义一般为两种，左闭右闭即[left, right]，或者左闭右开即[left, right)。
下面我用这两种区间的定义分别讲解两种不同的二分写法:
第一种写法：左闭右闭区间：
- while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=
- if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1
//左闭右闭区间
class Solution {
public int search(int[] nums, int target) {
// 避免当 target 小于nums[0] nums[nums.length - 1]时多次循环运算
if (target < nums[0] || target > nums[nums.length - 1]) {
return -1;
}
int left = 0;
//这里需要注意的是right = nums.length - 1
int right = nums.length - 1;
// 当left<= rigth的时候，left=mid+1,rigth = mid-1
while (left <= right) {
int mid = left + ((right - left)/2);
if (nums[mid] == target){
return mid;
}
else if (nums[mid] < target){
left = mid + 1;
}
else if (nums[mid] > target){
right = mid - 1;
}
}
return -1;
}
}
第二种：左闭右开区间
- while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
- if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]
//左闭右开区间
class Solution {
public int search(int[] nums, int target) {
// 避免当 target 小于nums[0] nums[nums.length - 1]时多次循环运算
if (target < nums[0] || target > nums[nums.length - 1]) {
return -1;
}
int left = 0;
//这里需要注意的是right = nums.length
int right = nums.length;
// 当left< rigth的时候，left=mid+1,rigth = mid
while (left < right) {
int mid = left + ((right - left)/2);
if (nums[mid] == target){
return mid;
}
else if (nums[mid] < target){
left = mid + 1;
}
else if (nums[mid] > target){
right = mid;
}
}
return -1;
}
}
相关的题目：
第一题：给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。请必须使用时间复杂度为 O(log n) 的算法。
//分析：这道题目说明了数组顺序已经排好了，而且是没有重复的元素，题目中明确规定了时间复杂度必须为 O(log n)，用二分法是非常合适的。代码如下：
class Solution {
public int searchInsert(int[] nums, int target) {
//当target小于数组的第一个元素，就只需要插入到第一个元素的前面就好了
if(target < nums[0]){
return 0;
}
//当target大于数组的最后一个元素，就只需要插入到最后的一个元素的后面就好了
if(target > nums[nums.length-1]){
return nums.length;
}
int start = 0;
int end = nums.length-1;
//注意，这里的等于号非常重要，当有等号的时候，end = index - 1，start = index - 1
while(start <= end){
int index = start + (end - start)/2;
if(nums[index] == target){
return index;
}else if(nums[index] > target){
end = index - 1;
}else{
start = index + 1;
}
}
//当在数组中找不到target的时候，经过数学计算，start的位置就是元素插入的位置
return start;
}
}
第二题：给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。
//分析：由于数据是有重复的，所以用二分法不太好做，所以这里我就用两个for循环来做，第一个for循环的目的是为了找到该数据的开始位置，第二个for循环的目的是为了找到该数据的结束位置。
class Solution {
public int[] searchRange(int[] nums, int target) {
//如果数组的长度为零，表示没有符合条件的值，直接返回{-1，-1}即可
if(nums.length == 0){
return new int[]{-1,-1};
}
//初始值都为-1，如果没有找到也是返回start,end，不用再new int[]{-1,-1}了
int start = -1;
int end = -1;
//用于找到符合条件的起始数据的下标
for(int i = 0;i < nums.length;i++){
if(nums[i] == target){
start = i;
end = i;
break;
}
}
//用于找到符合条件的终止数据的下标
for(int j = end+1;j < nums.length;j++){
if(nums[j] == target){
end++;
}
}
//直接返回由start,end构成的数组即可
return new int[]{start,end};
}
}
//另外一种写法：思路是先使用二分法找到目标值，然后使用左右指针分别向前和向后移动即可，如果找不到就直接返回-1即可
class Solution {
public int[] searchRange(int[] nums, int target) {
if(nums == null || nums.length == 0){
return new int[]{-1,-1};
}
int left = 0;
int right = nums.length-1;
while(left <= right){
int index = left + (right - left)/2;
if(nums[index] == target){
left = index;
right = index;
for(int i = left;i > 0;i--){
if(nums[left-1] == target){
left--;
}
}
for(int j = right;j < nums.length-1;j++){
if(nums[right+1] == target){
right++;
}
}
return new int[]{left,right};
}else if(nums[index] > target){
right = index - 1;
}else{
left = left + 1;
}
}
return new int[]{-1,-1};
}
}
第三题：给你一个非负整数 x ，计算并返回 x 的 算术平方根。由于返回类型是整数结果只保留整数部分小数部分将被舍去。注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5。
//分析：一个数的算数平方根肯定不会查过该数的一半，所以可以使用for循环来尝试，但是这样的时间复杂度太高了。如下面的代码：
class Solution {
public int mySqrt(int x) {
if(x == 0){
return 0;
}
if(x == 1){
return 1;
}
for(double i = 1;i <= (x/2);i++){
if(i * i == x || (i*i < x) && (i+1)*(i+1) > x){
return (int)i;
}
}
return -1;
}
}
//由于x的平方根的整数部分ans是满足k的平方的最大k值，因此我们可以对k进行二分查找，从而得到答案。代码如下：
class Solution {
public int mySqrt(int x) {
int start = 0;
int end = x;
int flag = -1;
while(start <= end){
int index = start + (end - start)/2;
if((long) index * index <= x){ //注意：这里一定要写(long) index * index
//这里必须使用一个标志来记录index的值，因为只有满足(long) index * index <= x条件的index才是返回值，所以这里是不能直接返回index的
flag = index;
start = index + 1;
}else{
end = index - 1;
}
}
return flag;
}
}
//二分查找的另外一种方式
class Solution {
public int mySqrt(int x) {
if(x == 0 || x == 1){
return x;
}
long left = 1;
long right = x/2;
while(left <= right){
long mid = left + (right - left)/2;
if(mid * mid == x ||
(mid * mid < x && (mid + 1) * (mid + 1) > x)){
return (int)mid;
}else if(mid * mid > x){
right = mid - 1;
}else{
left = mid + 1;
}
}
return -1;
}
}
第四题：给定一个正整数 num，编写一个函数，如果 num 是一个完全平方数，则返回 true，否则返回false。进阶：不要使用任何内置的库函数，如sqrt 。
//分析：如果使用sqrt函数是可以直接求出来的，但是这道题也可以使用二分法来做，代码如下：
class Solution {
public boolean isPerfectSquare(int num) {
if(num == 0 || num == 1){
return true;
}
long left = 1;
long right = num/2;
while(left <= right){
long mid = left + (right - left)/2;
if(mid * mid == num){
return true;
}else if(mid * mid > num){
right = mid - 1;
}else{
left = mid + 1;
}
}
return false;
}
}
以上是我根据代码随想录学习算法的思考，如有错误或者侵权的地方，请联系我改正或者删除。欢迎大家和我一起探讨关于java和算法的知识。
266
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
