二分查找

1.普通形式

1.线性查找：即for循环逐个查找
2.二分查找：

• 使用前提：在有序数组中查找

    public static int binarySearch(int []arr,int left,int right,int value){
        if(left>right){
            return -1;
        }
        int mid=(left+right)/2;
        int midVal=arr[mid];

        if(value>midVal){  //向右递归
            return binarySearch(arr,mid+1,right,value);
        }else if(value<midVal){
            return binarySearch(arr,left,mid-1,value);
        }else{
            return mid;
        }


    }

问题：如果有重复的数值，它找到一个就返回了。
改进：
思路分析：
在找到mid的索引值，不要立即返回，向它的左右扫描，将所有满足条件的下标加入到ArrayList集合中。最后返回集合。

改进后：

 public static List<Integer> binarySearch(int []arr,int left,int right,int value){
        if(left>right){
            return new ArrayList<Integer>();
        }
        int mid=(left+right)/2;
        int midVal=arr[mid];

        if(value>midVal){  //向右递归
            return binarySearch(arr,mid+1,right,value);
        }else if(value<midVal){
            return binarySearch(arr,left,mid-1,value);
        }else{
            List<Integer> list=new ArrayList<Integer>();


            int temp=mid-1;
            while(true){
                if(temp<0||arr[temp]!=value){
                    break;
                }
                    list.add(temp);
                    temp-=1;

            }
            list.add(mid);
            temp=mid+1;

            while(true){
                if(temp>arr.length-1||arr[temp]!=value){
                    break;
                }
                list.add(temp);
                temp+=1;
            }

            return list;
        }


    }

LeetCode

1.比如穿的参数不是直接的left和right，那还嫩恶搞递归个什么！
所以这时如果传的是目标值和数组，使用while（left<right)

---

看下这道题：LeetCode 35
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

你可以假设数组中无重复元素。

示例 1:

输入: [1,3,5,6], 5
输出: 2

---

开始分析：找不到则返回该放的位置，这里就要四两拨千金的想一想了！

二分是两边夹击的，所以如果不等于，你还是返回那个mid的序号就好了！！

 public static int searchInsert(int[] nums, int target) {
      int len = nums.length;
      if (len == 0) {
          return 0;
      }

      // 特判
      if (nums[len - 1] < target) {
          return len;
      }
      int left = 0;
      int right = len - 1;
      while (left < right) {
          int mid = (left + right) /2;
          // 严格小于 target 的元素一定不是解
          if (nums[mid] < target) {
              // 下一轮搜索区间是 [mid + 1, right]
              left = mid + 1;
          } else {
              right = mid;
          }
      }
      return left;
  }