二分法总结

二分法总结

使用条件：数据有序，按升序和降序都可以。

特点：每次选取数据的一半，可以显著的降低需要查找的数据量，降低查找操作的时间复杂度，提升算法性能。

二分法的时间复杂度：log₂ⁿ

时间复杂度分析：对一个长度为n的数组进行二分查找

当使用1次二分法时，剩余的数据量为n/2;

当使用2次二分法时，剩余的数据量为n/4;

当使用3次二分法时，剩余的数据量为n/2³;

当使用4次二分法时，剩余的数据量为n/2⁴;

…

当使用k次二分法时，剩余的数据量为1，则该数据就是我们想要的答案。

**n/2^k=1,k=log₂ⁿ,**使用log₂ⁿ即可将数据量为n的数据分完，因此二分法的事件复杂度为log₂ⁿ或者lgⁿ。

二分法模板

​ 二分法不难，难就难在边界值的确定，边界值的确定主要看循环终止条件，对于left<right，那循环终止条件就是left=right，而对于left<=right，循环终止条件就是left>right。

​ 二分法刚开始接触可能会觉得难，但是多做几道题就能做的游刃有余了。

模板1：查找非重复目标值

public int binarySearch(int [] nums,int target){
   
	int left = nums[0],right = nums[nums.length-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{
   
            right = mid -1;
        }
	}
    return -1;
}

模板2：查找非重复目标值（递归写法）

public boolean containsR(int nums[],int target){
   
    if (nums == null || nums.length ==0 ) return false;
    return contains(nums,0,nums.length-1,target);
}
//时间复杂度:O(Logn)
//空间复杂度:O(Logn)
private boolean contains(int []nums,int left,int right,int target){
   
    if (left>right) return false;
    int mid = left +(right-left)/2;
    if (nums[mid] ==target) return true;
    if (nums[mid] <target) {
   
        return contains(nums,mid+1,right,target);
    }else{
   
        return contains(nums,left,mid-1,target);
    }
}

模板3：查找重复目标值（查找第一位）

	//返回第一个大于等于目标元素的下标
	public int BasicBinarySearch(int nums[],int target){
   
        if (nums == null || nums.length ==0 ) return -1;
        int left=0,right=nums.length-1;
        while(left<=right){
   //循环终止条件 left>right
            int mid = left+(right- left)/2;
            if (nums[mid]== target){
   
                //1.mid是数组的第一个元素
                //2.mid前面的那个元素不等于target
                if (mid == 0 || nums[mid-1] != target){
   //注意防止数组越界
                    return mid;
                }else {
   
                    right = mid -1;//没找到，继续往左边查找
                }
            }else if (nums[mid]<target){
   
                left=mid+1;
            }else {
   
                right = mid-1;
            }
        }
        return -1;
    }

模板4：查找重复目标值（查找最后一位）

public int BasicBinarySearch(int nums[],int target){
   
        if (nums == null || nums.length ==0 ) return -1;
        int left=0,right=nums.length-1;
        while(left<=right){
   //循环终止条件 left>right
            int mid = left+(right- left)/2;
            if (nums[mid]== target){
   
                //1.mid是数组的第一个元素
                //2.mid前面的那个元素不等于target
                if (mid == nums.length-1 || nums[mid+1] > target){
   //注意防止数组越界
                    return mid;
                }else {
   
                    left = mid + 1;//没找到，继续往右边查找
                }
            }else if (nums[mid]>target){
   
                right=mid - 1;
            }else {
   
                left = mid + 1;
            }
        }
        return -1;
    }

模板5：查找重复目标值（查找第一位）

 //返回第一个大于等于目标元素的下标
public int searchFirst(int[] nums, int target) {
   
        int left=0,right=nums.length-1;
        while(left < right){
   //循环终止条件是left = right
            int mid = left+(right-left)/2;
            if(nums[mid] < target){
   
                left=mid+1;
            }else{
   
                right=mid;//会陷入死循环，查最后一个出现的目标元素会出现死循环
            }
        }
        return nums[left]==target? left:-1;
    }

​ 注意：上诉代码只能用于查找第一个大于等于目标值，而不能用于查找最后一个小于等于目标值，否则会陷入死循环

死循环演示：

 //返回最后一个大于等于目标元素的下标
public int searchFirst(int[] nums, int target) {
   
        int left=0,right=nums.length-1;
        while(left < right){
   //循环终止条件是left = right
            int mid = left+(right-left)/2;//加一可避免死循环
            if(nums[mid] <= target){
   
                left=mid;
            }else{
   
                right=mid-1;//会陷入死循环，查最后一个出现的目标元素会出现死循环
            }
        }
        return nums[left]==target? left:-1;
    }

模板6：查找重复目标值（查找最后一位）

 //返回最后一个小于等于目标元素的下标
public int searchFirst(int[] nums, int target) {
   
        int left=0,right=nums.length-1;
        while(left < right){
   //循环终止条件是left = right
            int mid = left+(right-left+1)/2;//必须+1，否则会陷入死循环
            if(nums[mid] > target){
   
                right=mid-1;
            }else{
   
                left=mid;
            }
        }
        return nums[left]==target? left:-1;
    }

​ 注意：上诉代码只能用于查找最后一个大=小于等于目标值，而不能用于查找第一个大于等于目标值，否则会陷入死循环

死循环演示：

 //返回第一个大于等于目标元素的下标
public int searchFirst(int[] nums, int target) {
   
        int left=0,right=nums.length-1;
        while(left < right){
   //循环终止条件是left = right
            int mid = left+(right-left+1)/2;//不能+1，否则会陷入死循环
            if(nums[mid] >= target){
   
                right=mid;
            }else{
   
                left=mid+1;
            }
        }
        return nums[left]==target? left:-1;
    }

模板7：查找重复目标值（查找第一位）

    public int searchFirst(int [] nums,int target){
   
        if(nums.length == 1){
   
            return nums[