二分法

一，求平方根

实现 int sqrt(int x) 函数。
计算并返回 x 的平方根，其中 x 是非负整数。
由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。
示例 1:
输入: 4
输出: 2
示例 2:
输入: 8
输出: 2

说明: 8 的平方根是 2.82842…,
由于返回类型是整数，小数部分将被舍去。

解法一：二分查找法

class Solution {
    public int mySqrt(int x) {
      if (x < 2) 
      return x;
      int num;
      int pivot, left = 2, right = x / 2;
      while (left <= right) {
        pivot = left + (right - left) / 2;
        num = x/pivot; //注意此处的处理
        if (num < pivot) right = pivot - 1;
        else if (num > pivot) left = pivot + 1;
        else return pivot;
      }
      return right;
    }
  }

class Solution {
  public int mySqrt(int x) {
    if (x < 2) return x;

    long num; //注意num是用的数据类型
    int pivot, left = 2, right = x / 2;
    while (left <= right) {
      pivot = left + (right - left) / 2;
      num = (long)pivot * pivot;
      if (num > x) right = pivot - 1;
      else if (num < x) left = pivot + 1;
      else return pivot;
    }

    return right;
  }
}

【注】：
除法没有四舍五入，小数取0.
基本数据类型的取值范围：
byte：-2^7 ~ 2^7-1，即-128 ~ 127。1字节。Byte。末尾加B

short：-2^15 ~ 2^15-1，即-32768 ~ 32767。2字节。Short。末尾加S

有符号int：-2^31 ~ 2^31-1，即-2147483648 ~ 2147483647。4字节。Integer。

无符号int：0~2^32-1。

long：-2^63 ~ 2^63-1，即-9223372036854774808 ~ 9223372036854774807。8字节。Long。末尾加L。（也可以不加L）

浮点型：
1、Float：比特数为32，4字节,有效数字为6-7，数值范围为 -3.4E+38 和 3.4E+38
2、Double：比特数为64，8字节有,效数字为15-16，数值范围为-1.7E-308～1.7E+308
可根据应用程序的需求将浮点变量声明为 float 或 double。这两种类型之间的主要差异在于它们可表示的基数、它们需要的存储以及它们的范围。

解法二：递归法

class Solution {
  public int mySqrt(int x) {
    if (x < 2) return x;

    int left = mySqrt(x >> 2) << 1;
    int right = left + 1;
    return (long)right * right > x ? left : right;
  }
}

二、大于给定元素的最小元素

题目描述：给定一个有序的字符数组 letters 和一个字符 target，要求找出 letters 中大于 target 的最小字符，如果找不到就返回第 1 个字符。
例：
Input:
letters = [“c”, “f”, “j”]
target = “d”
Output: “f”

Input:
letters = [“c”, “f”, “j”]
target = “k”
Output: “c”

public char nextGreatestLetter(char[] letters, char target) {

        int left=0;
        int right=letters.length - 1;
        while(left<=right)
        {
        int mid=left+(right-left)/2;
        if(letters[mid]<=target)
            left=mid+1;
        else
        right=mid-1;
        }
        return left< letters.length ? letters[left] : letters[0];
    }

三、第一个错误的版本

题目描述：给定一个元素 n 代表有 [1, 2, …, n] 版本，在第 x 位置开始出现错误版本，导致后面的版本都错误。可以调用 isBadVersion(int x) 知道某个版本是否错误，要求找到第一个错误的版本。

public int firstBadVersion(int n) {
        int left=1;
        int right=n;
        while(left<=right)
        {
            int mid = left+(right-left)/2;
            if(isBadVersion(mid))
            right=mid-1;
            else
            left=mid+1;
        }
        return left;
    }

四、旋转数组的最小数字

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

请找出其中最小的元素。

你可以假设数组中不存在重复元素。
解法一：
直接遍历

class Solution {
    public int findMin(int[] nums) {
        for(int i=0;i<nums.length-1;i++)
        {
            if(nums[i]>nums[i+1]){
               return nums[i+1];
            }
           
        }
        return nums[0];

    }
}

解法二：
二分法

public int findMin(int[] nums) {
    int l = 0, h = nums.length - 1;
    while (l < h) {
        int m = l + (h - l) / 2;
        if (nums[m] <= nums[h]) {
            h = m;
        } else {
            l = m + 1;
        }
    }
    return nums[l];
}

五、查找区间

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

你的算法时间复杂度必须是 O(log n) 级别。
如果数组中不存在目标值，返回 [-1, -1]。

解法一：
双指针

public int[] searchRange(int[] nums, int target) {
        int left=0;
        int right=nums.length-1;
        int arr[]={-1,-1};
        while(left<=right)
        {
            if(nums[left]==target&&nums[right]==target)
            {
                arr[0]=left;
                arr[1]=right;
                break;
            }
            if(nums[left]!=target)
            left++;
            if(nums[right]!=target)
            right--;

        }
        return arr;

    }

解法二：
二分法，进行两次二分法，第一次查找最左边的，第二次查找最右边的

class Solution {
    // returns leftmost (or rightmost) index at which `target` should be
    // inserted in sorted array `nums` via binary search.
    private int extremeInsertionIndex(int[] nums, int target, boolean left) {
        int lo = 0;
        int hi = nums.length;

        while (lo < hi) {
            int mid = (lo + hi) / 2;
            if (nums[mid] > target || (left && target == nums[mid])) {
                hi = mid;
            }
            else {
                lo = mid+1;
            }
        }

        return lo;
    }

    public int[] searchRange(int[] nums, int target) {
        int[] targetRange = {-1, -1};

        int leftIdx = extremeInsertionIndex(nums, target, true);

        // assert that `leftIdx` is within the array bounds and that `target`
        // is actually in `nums`.
        if (leftIdx == nums.length || nums[leftIdx] != target) {
            return targetRange;
        }

        targetRange[0] = leftIdx;
        targetRange[1] = extremeInsertionIndex(nums, target, false)-1;

        return targetRange;
    }
}

六、数组中的单一元素

给定一个只包含整数的有序数组，每个元素都会出现两次，唯有一个数只会出现一次，找出这个数。
解法一：二分法
奇数长度的数组首尾元素索引都为偶数，因此我们可以将 lo 和 hi 设置为数组首尾。
我们需要确保 mid 是偶数，如果为奇数，则将其减 1。
然后，我们检查 mid 的元素是否与其后面的索引相同。
如果相同，则我们知道 mid 不是单个元素。且单个元素在 mid 之后。则我们将 lo 设置为 mid + 2。
如果不是，则我们知道单个元素位于 mid，或者在 mid 之前。我们将 hi 设置为 mid。
一旦 lo == hi，则当前搜索空间为 1 个元素，那么该元素为单个元素，我们将返回它。

class Solution {
    public int singleNonDuplicate(int[] nums) {
        int lo = 0;
        int hi = nums.length - 1;
        while (lo < hi) {
            int mid = lo + (hi - lo) / 2;
            if (mid % 2 == 1) mid--;
            if (nums[mid] == nums[mid + 1]) {
                lo = mid + 2;
            } else {
                hi = mid;
            }
        }
        return nums[lo];
    }
}

解法二：异或

class Solution {
    public int singleNonDuplicate(int[] nums) {
        int first=nums[0];
        for (int i = 1; i < nums.length; i++) {
            first=first^nums[i];
        }
        return  first;
    }
}

小结

遇到有序的数组，优先想到二分查找法，遇到无序的数组，优先想到双指针。