算法学习100天——16 二分法总结
1 题目地址(69. x 的平方根 )
https://leetcode-cn.com/problems/sqrtx/
题目描述
给你一个非负整数 x ，计算并返回 x 的 算术平方根 。
由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。
注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。
示例 1：
输入：x = 4
输出：2
示例 2：
输入：x = 8
输出：2
解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。
提示：
0 <= x <= 231 - 1
Java Code:
// 这个题要注意的一点就是 不能用mid*mid 要用 x/mid 得出的sqrt来和mid比较大小
// 小于的话, mid大了，r移动过来
// 大于的话, mid小了，l移移过来
class Solution {
public int mySqrt(int x) {
if (x <= 1) {
return x;
}
int l = 0;
int r = x;
while(l <= r){
int mid = l + ((r - l) >> 1);
int sqrt = x / mid;
if(sqrt == mid){
return mid;
}else if(sqrt > mid){
l = mid + 1;
}else{
r = mid - 1;
}
}
return r;
}
}
2 题目地址(744. 寻找比目标字母大的最小字母)
https://leetcode-cn.com/problems/find-smallest-letter-greater-than-target/
题目描述
给你一个排序后的字符列表 letters ，列表中只包含小写英文字母。另给出一个目标字母 target，请你寻找在这一有序列表里比目标字母大的最小字母。
在比较时，字母是依序循环出现的。举个例子：
如果目标字母 target = 'z' 并且字符列表为 letters = ['a', 'b']，则答案返回 'a'
示例 1：
输入: letters = ["c", "f", "j"]，target = "a"
输出: "c"
示例 2:
输入: letters = ["c","f","j"], target = "c"
输出: "f"
示例 3:
输入: letters = ["c","f","j"], target = "d"
输出: "f"
提示：
2 <= letters.length <= 104
letters[i] 是一个小写字母
letters 按非递减顺序排序
letters 最少包含两个不同的字母
target 是一个小写字母
Java Code
// 就变形的二分查找
// 大于的话 将右边界移过来，小于或者等于就左边界移动端mid的右边
// 这样最后l >=r ,r就是恰好只大一点的那一个
class Solution {
public char nextGreatestLetter(char[] letters, char target) {
int l = 0;
int r = letters.length - 1;
while(l < r){
int mid = l + ((r - l) >> 1);
if(letters[mid] > target){
r = mid;
}else {
l = l + 1;
}
}
return letters[r] > target ? letters[r] : letters[0];
}
}
3 题目地址(540. 有序数组中的单一元素)
https://leetcode-cn.com/problems/single-element-in-a-sorted-array/
题目描述
给你一个仅由整数组成的有序数组，其中每个元素都会出现两次，唯有一个数只会出现一次。
请你找出并返回只出现一次的那个数。
你设计的解决方案必须满足 O(log n) 时间复杂度和 O(1) 空间复杂度。
示例 1:
输入: nums = [1,1,2,3,3,4,4,8,8]
输出: 2
示例 2:
输入: nums = [3,3,7,7,10,11,11]
输出: 10
提示:
1 <= nums.length <= 105
0 <= nums[i] <= 105
Java Code
class Solution {
// 求中点，数组二分处理
// 既然都是两两成对，那么目标值一定在奇数那边
// 只需要一直二分，保证目标值一直在奇数那边，就可以找到它
public int singleNonDuplicate(int[] nums) {
int l = 0, r = nums.length - 1;
while (l < r) {
int mid = l + ((r - l) >> 1);
// 这里要保证mid在数组下标的偶数位置，也就保证了mid左边或者右边的数组必为成对的
if (mid % 2 == 1) {
mid--;
}
// 相等则表示左边成对，不相等则表示右边成对
if (nums[mid == nums[mid + 1]) {
l = mid + 2;
} else {
r = mid;
}
}
return nums[l];
}
// 奇技淫巧 利用位运算的性质解题
public int singleNonDuplicate(int[] nums) {
int res = 0;
for(int n : nums){
res = res ^ n;
}
return res;
}
}
4 题目地址(278. 第一个错误的版本)
https://leetcode-cn.com/problems/first-bad-version/
题目描述
你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。
假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。
你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。
示例 1：
输入：n = 5, bad = 4
输出：4
解释：
调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true
所以，4 是第一个错误的版本。
示例 2：
输入：n = 1, bad = 1
输出：1
提示：
1 <= bad <= n <= 231 - 1
Java Code
// 这个题应该是比较简单的，就是单纯的二分查找，左边都是没出错的，右边都是出错的
/* The isBadVersion API is defined in the parent class VersionControl.
boolean isBadVersion(int version); */
public class Solution extends VersionControl {
public int firstBadVersion(int n) {
int l = 0;
int r = n;
while(l < r - 1){
int mid = l + ((r - l) >> 1);
if(isBadVersion(mid)){
r = mid;
} else{
l = mid;
}
}
return r;
}
}
5 题目地址(153. 寻找旋转排序数组中的最小值)
https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/
题目描述
已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：
若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]
若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]
注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]]。
给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。
示例 1：
输入：nums = [3,4,5,1,2]
输出：1
解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。
示例 2：
输入：nums = [4,5,6,7,0,1,2]
输出：0
解释：原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。
示例 3：
输入：nums = [11,13,15,17]
输出：11
解释：原数组为 [11,13,15,17] ，旋转 4 次得到输入数组。
提示：
n == nums.length
1 <= n <= 5000
-5000 <= nums[i] <= 5000
nums 中的所有整数 互不相同
nums 原来是一个升序排序的数组，并进行了 1 至 n 次旋转
Java Code
class Solution {
// 二分版本，只需要比较中间值是大于还是小于右边的，
// 如果大于，说明数组中还存在旋转的数组，则把左边边界移过来，最小值在mid-r之间
// 如果小于，说明不存在旋转数组了，只需要将右边界移过来，最小值在l-mid之间
public int findMin(int[] nums) {
int l = 0, r = nums.length - 1;
while (l < r) {
int mid = l + (r - l) / 2;
if (nums[mid] <= nums[r]) {
r = mid;
} else {
l = mid + 1;
}
}
return nums[l];
}
// 贪心思想，因为只需要找到局部最小值，然后局部最小值比较获取最小值
public int findMin(int[] nums) {
return findMin(0, nums.length - 1, nums);
}
public int findMin(int l, int r, int[] nums){
if(l == r){
return nums[l];
}
int mid = l + ((r - l) >> 1);
int left = findMin(l, mid, nums);
int right = findMin(mid + 1, r, nums);
return left <= right ? left : right;
}
}
6 题目地址(34. 在排序数组中查找元素的第一个和最后一个位置)
https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/
题目描述
给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target，返回 [-1, -1]。
进阶：
你可以设计并实现时间复杂度为 O(log n) 的算法解决此问题吗？
示例 1：
输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]
示例 2：
输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]
示例 3：
输入：nums = [], target = 0
输出：[-1,-1]
提示：
0 <= nums.length <= 105
-109 <= nums[i] <= 109
nums 是一个非递减数组
-109 <= target <= 109
Java Code:
// 将问题拆分为两个：
// 一个是找第一个等于target的，如题4
// 另一个是最后一个等于target的(也可以是第一个大于target的，如题2)
// 感觉还能写进一个方法，再思考思考
class Solution {
public int[] searchRange(int[] nums, int target) {
int left = findLeftBound(nums, target);
int right = findRightBound(nums, target);
return new int[]{left, right};
}
public int findLeftBound(int[] nums, int target){
if (nums.length < 1){
return -1;
}
int l = 0;
int r = nums.length - 1;
while(l < r){
int mid = l + ((r - l) >> 1);
if(nums[mid] < target){
l = mid + 1;
}else {
r = mid;
}
}
return nums[l] == target ? l : -1;
}
public int findRightBound(int[] nums, int target){
if (nums.length < 1){
return -1;
}
int l = 0;
int r = nums.length - 1;
while(l < r){
int mid = l + ((r - l) >> 1) + 1;
if(nums[mid] <= target){
l = mid;
}else {
r = mid - 1;
}
}
return nums[r] == target ? r : -1;
}
}
