【算法】二分查找 及 搜索左右边界的二分 三分法及应用二分法的leetcode题 33搜索旋转排序数据

1.二分法

在升序数组中寻找元素

//普通的二分
	public static int baseBinarySearch(int []nums,int tar){
		if (nums.length == 0) return -1;
		int left=0;
		int right=nums.length-1;
		int mid;
		while(left<=right){
			mid=(left+right)/2;
			if (nums[mid]==tar) {
				return mid;
			}else if(nums[mid]<tar){
				left=mid+1;
			}else {
				right=mid-1;
			}
		}
		return -1;
	}

在不递减数组中寻找元素（存在重复数字）

import java.util.*;
public class Solution {
	
	//搜索左边边界的二分  具体含义是：nums 中小于 tar的元素有 几 个。
	public static int leftBinarySearch(int []nums,int tar){
		if(nums.length==0) return 0;
		int left=0;
		int right=nums.length-1;
		int mid;
		while(left<=right){
			mid=(left+right)>>1;
			if(nums[mid]==tar){
				right=mid-1;
			}else if(nums[mid]<tar){
				left=mid+1;
			}else{
				right=mid-1;
			}
		}
		return left;
	}
	
	//搜索左边边界的二分  具体含义是：找最左下标，没有返回-1。
	public static int leftBinarySearch1(int []nums,int tar){
			if(nums.length==0) return 0;
			int left=0;
			int right=nums.length-1;
			int mid;
			while(left<=right){
				mid=(left+right)>>1;
				if(nums[mid]==tar){
					right=mid-1;
				}else if(nums[mid]<tar){
					left=mid+1;
				}else{
					right=mid-1;
				}
			}
			if (left>=nums.length||nums[left]!=tar) {
				return -1;
			}
			return left;
		}
	
	//搜索右边边边界的二分  具体含义是：找最右下标，没有返回-1。
		public static int rightBinarySearch(int []nums,int tar){
				if(nums.length==0) return 0;
				int left=0;
				int right=nums.length-1;
				int mid;
				while(left<=right){
					mid=(left+right)>>1;
					if(nums[mid]==tar){
						left=mid+1;
					}else if(nums[mid]<tar){
						left=mid+1;
					}else{
						right=mid-1;
					}
				}
				if (right<0||nums[right]!=tar) {
					return -1;
				}
				return right;
			}
	public static void main(String[] args) {
		int[] nums={-3,-2,-1,1,2,2,2,3,4};
		int tar=-9;
		System.out.println(rightBinarySearch(nums,tar));
	}

    
}

在山脉数组中寻找山顶元素

//找山顶元素
        int left=0;
        int right=mountainArr.length()-1;
        int mid;
        int top=0;
        while(left<right){
            mid=(left+right)>>1;
            if(mountainArr.get(mid)<mountainArr.get(mid+1)){
                left=mid+1;
            }else{
                right=mid;
            }

        }

2.三分法（山脉数组找山顶）

	//三分法 求数组 最大值
	public static int threeSearch(int []nums){
		int left=0;
		int right=nums.length-1;
		int mid,midright;
		while(right-left >1){//可接受的误差
			mid=(left+right)>>1;
			midright=(mid+right)>>1;
			if (calFun(nums[mid])<calFun(nums[midright])) {
				right=midright;
			}else{
				left=mid;
			}
		}
		return left;
	}
	public static int calFun(int num){//比较的函数值
		return num;
	}
	public static void main(String[] args) {
		int[] nums={-1,1,2,2,2,3,4,3,1,0};
		System.out.println(threeSearch(nums));
	}

3.搜索旋转排序数据（二分思想）

33. 搜索旋转排序数组 leetcode地址

class Solution {
    public int search(int[] nums, int target) {
        int left=0;
        int right=nums.length-1;
        int mid;
        while(left<=right){
            mid=(left+right)>>1;
            if(nums[mid]==target)
                return mid;
            if(nums[left]<=nums[mid]){//左边是有序的
                //判断target在不在左边
                if(nums[left]<=target&&target<nums[mid])
                    right=mid-1;
                else left=mid+1;
            }else if(nums[mid]<=nums[right]){//右边的是有序的
                if(nums[mid]<target&&target<=nums[right]) 
                    left=mid+1;
                else right=mid-1;
            }
        }
        return -1;
    }
}

面试题 10.03. 搜索旋转数组

class Solution {
    public int search(int[] arr, int target) {
        int left=0;
        int right=arr.length-1;
        int mid;
        if(arr[0]==target) return 0;
        while(left<=right){
            mid=(left+right)>>1;
            if(arr[mid]==target){
                while(mid-1>=0&&arr[mid-1]==arr[mid]){
                    mid=mid-1;
                }
                return mid;
            }
            //无法判断是否有序
            if(arr[left]==arr[mid]&&arr[right]==arr[mid])left++;
            //左边是有序的
            else if(arr[left]<=arr[mid]){
                //判断target在不在左边
                if(arr[left]<=target&&target<arr[mid])
                    right=mid-1;
                else left=mid+1;
            }else{//右边的是有序的
                if(arr[mid]<target&&target<=arr[right]) 
                    left=mid+1;
                else right=mid-1;
            }
        }
        return -1;

    }
}

81. 搜索旋转排序数组 II

class Solution {
    public boolean search(int[] nums, int target) {
        int left=0;
        int right=nums.length-1;
        int mid;
        while(left<=right){
            mid=(left+right)>>1;
            if(nums[mid]==target){
                return true;
            }
            if(nums[left]<nums[mid]){
                if(nums[left]<=target&&target<nums[mid]){
                    right=mid-1;
                }else{
                    left=mid+1;
                }
            }else if(nums[left]>nums[mid]){
                if(nums[mid]<target&&target<=nums[right]){
                    left=mid+1;
                }else{
                    right=mid-1;
                }
            }else {  //注意这里！！！！！!！！！！！！!！
                left++;
            }
    
            
        }
        return false;
    }
}

4.山脉数组中查找目标值

1095. 山脉数组中查找目标值

/**
 * // This is MountainArray's API interface.
 * // You should not implement it, or speculate about its implementation
 * interface MountainArray {
 *     public int get(int index) {}
 *     public int length() {}
 * }
 */
 
class Solution {
    public int findInMountainArray(int target, MountainArray mountainArr) {
        //找山顶元素
        int left=0;
        int right=mountainArr.length()-1;
        int mid;
        int top=0;
        while(left<right){
            mid=(left+right)>>1;
            if(mountainArr.get(mid)<mountainArr.get(mid+1)){
                left=mid+1;
            }else{
                right=mid;
            }

        }
        top=left;
        //左边寻找target
        left=0;
        right=top;
        while(left<=right){
            mid=(left+right)>>1;
            int tmp=mountainArr.get(mid);
            if(tmp==target){
                return mid;
            }else if(tmp<target){
                left=mid+1;
            }else{
                right=mid-1;
            }
        }
        //右边寻找target
        left=top;
        right=mountainArr.length()-1;
        while(left<=right){
            mid=(left+right)>>1;
            int tmp=mountainArr.get(mid);
            if(tmp==target){
                return mid;
            }else if(tmp<target){
                right=mid-1;
            }else{
                left=mid+1;
            }
        }
        return -1;
    }
}