##数组二分查找
###[循环右移了k位]
有一升序数组，现循环右移了k位（k未知），求k的值。
#include <iostream>
#include <vector>
using namespace std;
int Fun(vector<int> &nums){
if(nums.size() == 0 || nums[0]<nums.back()) return 0;
int l = 0,r = nums.size()-1;
while (l + 1 < r){//跳出时，r = l + 1，且nums[l] > nums[r]
int mid = l + (r - l)/2;
//找分界的点，排除升序的，但保留mid,因为mid可能是转折点
if(nums[l] < nums[mid]){
l = mid;
}else if(nums[l] > nums[mid]){
r = mid;
}else l++;//如果有重复的
}
return l + 1;
}
int main()
{
vector<int> nums = {4,5,6,7,8,8,8,8,10,1,2,3,4};
cout << Fun(nums) << endl;
return 0;
}
###[搜索旋转排序数组](https://leetcode-cn.com/problems/search-in-rotated-sorted-array)
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。
你可以假设数组中不存在重复的元素。
你的算法时间复杂度必须是 O(log n) 级别。
示例 1:
输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4
示例 2:
输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1
本方法支持重复(包括不重复)
class Solution {
public:
int search(vector<int>& nums, int target) {
int min = 0, max = nums.size() - 1, mid = 0;
while(min <= max){
mid = (min + max) / 2;
if(nums[mid] == target){
return mid;
}
if(nums[min] < nums[mid]){// 如果左半部分是有序的
if(nums[min] <= target && target < nums[mid]){
max = mid - 1;
} else {
min = mid + 1;
}
} else if (nums[min] > nums[mid]){// 如果右半部份是有序的
if(nums[mid] < target && target <= nums[max]){
min = mid + 1;
} else {
max = mid - 1;
}
}
else ++min;//min == mid 则移动min
}
return -1;
}
};
本方法不支持重复
class Solution {
public:
int search(vector<int>& nums, int target) {
int left = 0,right = nums.size() -1,mid;
while(left <= right)
{
mid = left + (right-left)/2;
if (nums[mid] == target)return mid;
//必须是mid 和right，不能是left、mid，否则不能处理[3,1] 1这种特殊情况，此时mid==left且nums[mid] > nums[max]
if (nums[mid] < nums[right])
{
if (nums[mid] < target && target <= nums[right]) left = mid + 1;
else right = mid -1;
}
else //if (nums[mid] > nums[right])
{
if (nums[left] <= target && target < nums[mid]) right = mid - 1;
else left = mid + 1;
}
}
return -1;
}
};
###[搜索旋转排序数组 II](https://leetcode-cn.com/problems/search-in-rotated-sorted-array-ii)
已知存在一个按非降序排列的整数数组 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,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4] 。
给你 旋转后 的数组 nums 和一个整数 target ，请你编写一个函数来判断给定的目标值是否存在于数组中。如果 nums 中存在这个目标值 target ，则返回 true ，否则返回 false 。
你必须尽可能减少整个操作步骤。
示例 1：
输入：nums = [2,5,6,0,0,1,2], target = 0
输出：true
示例 2：
输入：nums = [2,5,6,0,0,1,2], target = 3
输出：false
提示：
1 <= nums.length <= 5000
-104 <= nums[i] <= 104
题目数据保证 nums 在预先未知的某个下标上进行了旋转
-104 <= target <= 104
进阶：
这是 搜索旋转排序数组 的延伸题目，本题中的 nums 可能包含重复元素。
这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？
class Solution {
public:
bool search(vector<int>& nums, int target) {
int l = 0, r = nums.size() - 1, mi = 0;
while(l <= r){
mi = l + (r - l) >>1;
if(nums[mi] == target){
return true;
}
if(nums[l] < nums[mi]){// 左半部分有序
if(nums[l] <= target && target < nums[mi]){
r = mi - 1;
} else {
l = mi + 1;
}
} else if (nums[l] > nums[mi]){// 右半部份有序
if(nums[mi] < target && target <= nums[r]){
l = mi + 1;
} else {
r = mid - 1;
}
}
else ++l;
}
return false;
}
};
/*
假设原数组是{1,2,3,3,3,3,3}，那么旋转之后有可能是{3,3,3,3,3,1,2}，或者{3,1,2,3,3,3,3}，这样的我们判断左边缘和中心的时候都是3，如果我们要寻找1或者2，我们并不知道应该跳向哪一半。解决的办法只能是对边缘移动一步，直到边缘和中间不在相等或者相遇，这就导致了会有不能切去一半的可能。所以最坏情况（比如全部都是一个元素，或者只有一个元素不同于其他元素，而他就在最后一个）就会出现每次移动一步，总共是n步，算法的时间复杂度变成O(n)
*/
##两数组的二分查找
###[寻找两个有序数组的中位数](https://leetcode-cn.com/problems/median-of-two-sorted-arrays)
给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。
算法的时间复杂度应该为 O(log (m+n)) 。
示例 1：
输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2
示例 2：
输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5
提示：
nums1.length == m
nums2.length == n
0 <= m <= 1000
0 <= n <= 1000
1 <= m + n <= 2000
-106 <= nums1[i], nums2[i] <= 106
关键在于在nums1中一直寻找mid1，使mid1的左右两数跟mid2的左右两数是交错的（到边界也算）,之后就用mid1、mid2两边4个数来算中位数
二分查,复杂度log(m + n)
class Solution {
public:
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
if(nums1.size() > nums2.size()) return findMedianSortedArrays(nums2,nums1);//保证mid2的访问
int length = nums1.size() + nums2.size();
int left1 = 0, right1 = nums1.size();
double result = 0;
while (left1 <= right1) //mid1二分查找
{
int mid1 = left1 + (right1 - left1)/2;
int mid2 = (length+1)/2 - mid1;
if(mid1 > 0 && nums1[mid1-1] > nums2[mid2]) right1 = mid1-1;
else if(mid1 != nums1.size() && nums1[mid1] < nums2[mid2-1]) left1 = mid1+1;
else{
int L1 = mid1 > 0 ?nums1[mid1-1]:INT_MIN;
int R1 = mid1 == nums1.size() ?INT_MAX:nums1[mid1];
int L2 = mid2 > 0 ?nums2[mid2-1]:INT_MIN;
int R2 = mid2 == nums2.size() ?INT_MAX:nums2[mid2];
result = (length % 2 != 0) ? max(L1,L2):(max(L1,L2)+min(R1,R2))/2.0;
break;
}
}
return result;
}
};
##数字运算有关的二分
###第一个错误的版本(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
方法1
class Solution {
public:
int firstBadVersion(int n) {
if (n < 1)return -1;
int left = 1,right = n,mid = -1,bad = -1;
while(left <= right)
{
mid = left + (right-left)/2;
if (isBadVersion(mid)){bad = mid;right = mid -1;}
else left = mid + 1;
}
return bad;
}
};
看上去比方法2 简单点，效率差不多
方法2
class Solution {
public:
int firstBadVersion(int n) {
if(n < 1)return -1;
int low = 1,high = n,mid;
// 跳出时high = low + 1，high和low哪个是第一个bad需要判断
while(low + 1 < high)
{
mid = low + (high - low) / 2;
if(isBadVersion(mid)) {high = mid;} //需要包含该bad
else {low = mid;}//需要包含该good
}
if(isBadVersion(low)) {return low;}
else if(isBadVersion(high)) {return high;}
return -1;
}
};
###[x 的平方根](https://leetcode-cn.com/problems/sqrtx)
实现 int sqrt(int x) 函数。
计算并返回 x 的平方根，其中 x 是非负整数。
由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。
示例 1:
输入: 4
输出: 2
示例 2:
输入: 8
输出: 2
说明: 8 的平方根是 2.82842...,
由于返回类型是整数，小数部分将被舍去。
class Solution {
public:
int mySqrt(int x) {
double begin = 0,end = x,target = 1,mid=1;//result需要从1开始，避免小数被取整时被清除
while(abs(x - target) > 0.000001){
mid = (begin + end) / 2;
target = mid * mid;
if(target > x) end = mid;
else begin = mid;
}
return (int)mid;
}
};
###[Pow(x, n)](https://leetcode-cn.com/problems/powx-n)
实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。
示例 1：
输入：x = 2.00000, n = 10
输出：1024.00000
示例 2：
输入：x = 2.10000, n = 3
输出：9.26100
示例 3：
输入：x = 2.00000, n = -2
输出：0.25000
解释：2-2 = 1/22 = 1/4 = 0.25
class Solution {
public:
double myPow(double x, int n) {
double res(1.0);
for(int k = abs(n);k != 0;k/=2)
{
if (k % 2 == 1)
{
res *= x;
}
x *= x;
}
return n < 0? 1/res:res;
}
};
###[有效的完全平方数](https://leetcode-cn.com/problems/valid-perfect-square)
给定一个 正整数 num ，编写一个函数，如果 num 是一个完全平方数，则返回 true ，否则返回 false 。
进阶：不要 使用任何内置的库函数，如 sqrt 。
示例 1：
输入：num = 16
输出：true
示例 2：
输入：num = 14
输出：false
二分尝试
class Solution {
public:
bool isPerfectSquare(int num) {
int left = 1,right = num;
long mid,tmp;
while(left <= right)
{
mid = left + (right - left)/2;;
tmp = mid * mid;
if (tmp == num)return true;
else if (tmp < num)left = mid + 1;
else right = mid - 1;
}
return false;
}
};
1345
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
