二分查找（一）

一、概述

1、什么是二分查找？

二分查找是计算机科学中最基本、最有用的算法之一。 它描述了在有序集合中搜索特定值的过程。

二分查找中使用的术语：

目标 Target —— 你要查找的值

索引 Index —— 你要查找的当前位置

左、右指示符 Left，Right —— 我们用来维持查找空间的指标

中间指示符 Mid —— 我们用来应用条件来确定我们应该向左查找还是向右查找的索引

2、它是如何工作的？

在最简单的形式中，二分查找对具有指定左索引和右索引的连续序列进行操作。这就是所谓的查找空间。二分查找维护查找空间的左、右和中间指示符，并比较查找目标或将查找条件应用于集合的中间值；如果条件不满足或值不相等，则清除目标不可能存在的那一半，并在剩下的一半上继续查找，直到成功为止。如果查以空的一半结束，则无法满足条件，并且无法找到目标。

在接下来的内容中，我们将回顾如何识别二分查找问题，“为什么我们使用二分查找” 这一问题的原因，以及你以前可能不知道的 3 个不同的二分查找模板。

由于二分查找是一个常见的面试主题，我们还将练习问题按不同的模板进行分类，以便你可以在实践使用到每一个。

注意：

二进制搜索可以采用许多替代形式，并且可能并不总是直接搜索特定值。有时您希望应用特定条件或规则来确定接下来要搜索的哪一侧（左侧或右侧）。

3、识别和模板

如何识别二分查找？

如前所述，二分查找是一种在每次比较之后将查找空间一分为二的算法。每次需要查找集合中的索引或元素时，都应该考虑二分查找。如果集合是无序的，我们可以总是在应用二分查找之前先对其进行排序。

成功的二分查找的 3 个部分

二分查找一般由三个主要部分组成：

预处理 —— 如果集合未排序，则进行排序。

二分查找 —— 使用循环或递归在每次比较后将查找空间划分为两半。

后处理 —— 在剩余空间中确定可行的候选者。

3 个二分查找模板

当我们第一次学会二分查找时，我们可能会挣扎。我们可能会在网上研究数百个二分查找问题，每次我们查看开发人员的代码时，它的实现似乎都略有不同。尽管每个实现在每个步骤中都会将问题空间划分为原来的 1/2，但其中有许多问题：

为什么执行方式略有不同？

开发人员在想什么？

哪种方法更容易？

哪种方法更好？

二、模板一

int binarySearch(int[] nums, int target){
  if(nums == null || nums.length == 0)
    return -1;
  int left = 0, right = nums.length - 1;
  while(left <= right){
    // Prevent (left + right) overflow
    int mid = left + (right - left) / 2;
    if(nums[mid] == target){ return mid; }
    else if(nums[mid] < target) { left = mid + 1; }
    else { right = mid - 1; }
  }
  // End Condition: left > right
  return -1;
}

模板 一， 是二分查找的最基础和最基本的形式。这是一个标准的二分查找模板。

模板一用于查找可以通过访问数组中的单个索引来确定的元素或条件。

关键属性

二分查找的最基础和最基本的形式。

查找条件可以在不与元素的两侧进行比较的情况下确定（或使用它周围的特定元素）。

不需要后处理，因为每一步中，你都在检查是否找到了元素。如果到达末尾，则知道未找到该元素。

区分语法

初始条件：left = 0, right = length-1

终止：left > right

向左查找：right = mid-1

向右查找：left = mid+1

 三、例子

1、计算并返回 x 的 算术平方根 。（x为非负整数 ）

由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。

注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

示例 1：

输入：x = 4

输出：2

示例 2：

输入：x = 8

输出：2

解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。

提示：

0 <= x <= 231 - 1

class Solution {
    public int mySqrt(int x) {
        if(x < 2)
            return x;
        int left = 1, right = x;
        while(left <= right){
            int mid = (left + right) >>> 1;
            if(x / mid == mid)
                return mid;
            else if(x / mid < mid)
                right = mid - 1;
            else
                left = mid + 1;
        }
        return right;
    }
}

2、猜数字大小

猜数字游戏的规则如下：

每轮游戏，我都会从 1 到 n 随机选择一个数字。 请你猜选出的是哪个数字。

如果你猜错了，我会告诉你，你猜测的数字比我选出的数字是大了还是小了。

你可以通过调用一个预先定义好的接口 int guess(int num) 来获取猜测结果，返回值一共有 3 种可能的情况（-1，1 或 0）：

-1：我选出的数字比你猜的数字小 pick < num

1：我选出的数字比你猜的数字大 pick > num

0：我选出的数字和你猜的数字一样。恭喜！你猜对了！pick == num

返回我选出的数字。

示例 1：

输入：n = 10, pick = 6

输出：6

示例 2：

输入：n = 1, pick = 1

输出：1

示例 3：

输入：n = 2, pick = 1

输出：1

示例 4：

输入：n = 2, pick = 2

输出：2

提示：

1 <= n <= 231 - 1

1 <= pick <= n

/** 
 * Forward declaration of guess API.
 * @param  num   your guess
 * @return       -1 if num is lower than the guess number
 *                1 if num is higher than the guess number
 *               otherwise return 0
 * int guess(int num);
 */
public class Solution extends GuessGame {
   public int guessNumber(int n) {
        //如果不为0说明没有猜中
        int left=0;
        int right=n;
        int mid=0;
        int flag;
        while(left <= right){
            mid=left+(right-left)/2;
            flag=guess(mid);
            if(flag==1){
                left=mid+1;
            }else if(flag==-1){
                right=mid-1;
            }else{
                return mid;
            }
        }
        return -1;
    }
}

3、搜索旋转排序数组

整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

示例 1：

输入：nums = [4,5,6,7,0,1,2], target = 0

输出：4

示例 2：

输入：nums = [4,5,6,7,0,1,2], target = 3

输出：-1

示例 3：

输入：nums = [1], target = 0

输出：-1

class Solution {
    public static int search(int[] nums, int target) {
        if(nums == null){
            return -1;
        }
        if( nums.length == 1){
            if(nums[0] != target){
                return -1;
            }else{
                return 0;
            }
        }
        int index = getBreakPoint(nums);
        if(index == -1){
            return search(nums,target, 0,nums.length-1);
        }
        int num1 = search(nums, target, 0, index-1);
        if(num1 != -1){
            return num1;
        }
        int num2 = search(nums, target, index, nums.length-1);
        if(num2 != -1){
            return num2;
        }
        return -1;
    }
    public static int search(int[] nums, int target, int start1, int end1){
        int start = start1;
        int end = end1;
        int mid = 0;
        while(start <= end){
            mid = start + (end - start)/2;
            if(nums[mid] == target){
                return mid;
            }else if(nums[mid] < target){
                start = mid +1;
            }else{
                end = mid -1;
            }
        }
        return -1;
    }
    public static int getBreakPoint(int[] nums){
        int i = 0;
        int j = i+1;
        while(j < nums.length){
            if(nums[i] > nums[j] ){
                return j;
            }
            i++;
            j++;
        }
        return -1;
    } 
}