本文展示了二分查找算法在多个数组操作中的应用，包括判断有序数组中是否存在某个值、找到数的最左侧位置、寻找局部最小值、计算两个有序数组的中位数以及在旋转数组中搜索目标值和找到最小元素。这些方法都利用了二分查找的效率，实现了O(logn)的时间复杂度解决方案。
1.在一个有序数组中找到某个值是否存在
bool BSExist(vector<int>arr,int num){
int size=arr.size();
if(size==0){
return false;
}
int left=0;
int right=size-1;
while(left<right){//left和right最后是前后的位置，不会重合
int mid=left+(right-left)>>1;
if(arr[mid]>num){
right=mid-1;
}else if(arr[mid]<num){
left=mid+1;
}else{
return true;
}
}
return arr[left]==num;
}
2.在一个有序数组中找到某个数最左侧的位置的索引
int BSNearleft(vector<int>arr,int num){
int size=arr.size();
int left=0;
int right=size-1;
while(left<=right){//<=表示left和right最后会重合
int mid=left+((right-left)>>1);
if(arr[mid]>=num){//能找到规定值最左边的前一个值
right=mid-1;
}else{
left=mid+1;
};
}
return left;
}
3.一个无序数组找到一个局部最小值（相邻不相等）
int BSAwesome(vector<int>arr){
int size=arr.size();
if(size==0){
return -1;
}
if(arr[0]<arr[1]){
return 0;
}
if(arr[size-1]<arr[size-2]){
return size-1;
}
int left=0;
int right=size-1;
while(left<right){
int mid=left+((right-left)>>1);
if(arr[mid]>arr[mid-1]){
right=mid-1;
}else if(arr[mid]>arr[mid+1]){
left=mid+1;
}else{//arr[mid]<=arr[mid-1]&&arr[mid]<=arr[mid+1]
return mid;
}
}
return left;//left是最后一个数为right的最后的值
}
4.给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。
算法的时间复杂度应该为 O(log (m+n)) 。
double getKthElement(vector<int> &nums1, vector<int> &nums2, int k) {
int m=nums1.size();
int n=nums2.size();
int index1=0,index2=0;
while(true){
//边界条件
if(index1==m){
return nums2[index2+k-1];
}
if(index2==n){
return nums1[index1+k-1];
}
if(k==1){
return min(nums1[index1],nums2[index2]);
}
//正常情况
int newIndex1=min(index1+k/2-1,m-1);
int newIndex2=min(index2+k/2-1,n-1);
int pivot1=nums1[newIndex1];
int pivot2=nums2[newIndex2];
if(pivot1<=pivot2){
k-=newIndex1-index1+1;
index1=newIndex1+1;
}else{
k-=newIndex2-index2+1;
index2=newIndex2+1;
}
}
}
double findMedianSortedArrays(vector<int>&nums1, vector<int>& nums2){
int totallength=nums1.size()+nums2.size();
if(totallength%2==1){
return getKthElement(nums1,nums2,(totallength+1)/2);
}else{
return ((getKthElement(nums1,nums2,totallength/2))+ (getKthElement(nums1,nums2,totallength/2+1)))/2;
}
}
double getKth(vector<int> &nums1, int start1, int end1, vector<int> &nums2, int start2, int end2, int k) {
int len1=end1-start1+1;
int len2=end2-start2+1;
//让len1的长度小于len2,这样就能保证如果有数组为空，一定是len1
if(len1>len2)return getKth(nums2,start2,end2,nums1,start1,end1,k);
if(len1==0){
return nums2[start2+k-1];
}
if(k==1){
return min(nums1[start1],nums2[start2]);
}
int i=start1+min(len1,k/2)-1;
int j=start2+min(len2,k/2)-1;
if(nums1[i]>nums2[j]){
return getKth(nums1,start1,end1,nums2,j+1,end2,k-(j-start2+1));
}else{
return getKth(nums1,i+1,end1,nums2,start2,end2,k-(i-start1+1));
}
}
double findMedianSortedArrays(vector<int>&nums1, vector<int>&nums2){
int n=nums1.size();
int m=nums2.size();
int left=(n+m+1)/2;
int right=(n+m+2)/2;
return (getKth(nums1,0,n-1,nums2,0,m-1,left)+ (getKth(nums1,0,n-1,nums2,0,m-1,right)))/2;
}
5.整数数组 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 。
int search(vector<int>& nums, int target) {
int len=nums.size();
int left=0;
int right=len-1;
int mid=0;
while(left<=right) {
mid=left+((right-left)>>1);
if(nums[left]<nums[mid]){
if(nums[mid]==target){
return mid;
}else if(nums[left]==target){
return left;
}else if(nums[right]==target){
return right;
}else if(nums[left]<target&&nums[mid]>target){
right=mid-1;
}else if(nums[mid]<target||nums[left]>target){
left=mid+1;
}
}else{
if(nums[mid]==target){
return mid;
}else if(nums[left]==target){
return left;
}else if(nums[right]==target){
return right;
}else if(nums[left]<target||nums[mid]>target){
right=mid-1;
}else if(nums[left]>target&&nums[mid]<target){
left=mid+1;
}
}
return -1;
}
6.在排序数组中查找元素的第一个和最后一个位置
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target，返回 [-1, -1]。
vector<int> searchRange(vector<int>& nums, int target) {
int len=nums.size();
int left=0;
int right=len-1;
int mid=0;
int l=-1,r=-1;
while(left<=right){
int mid=left+((right-left)>>1);
if(nums[mid]>target){
right=mid-1;
}else if(nums[mid]<target){
left=mid+1;
}else{
l=r=mid;
while(l>0&&nums[l-1]==target){
l--;
}
while(r<len-1&&nums[r+1]==target){
r++;
}
return {l,r};
}
}
return {l,r};
}
int binarySearch(vector<int> &nums, int target, bool lower) {
int left=0,right=(int)nums.size()-1,ans=(int)nums.size();
while(left<=right){
int mid=(left+right)/2;
if(nums[mid]>target||(lower&&nums[mid]>=target)){//找最左测的点，找最右测得点
right=mid-1;
ans=mid;
}else{
left=mid+1;
}
}
return ans;
}
vector<int> searchRange(vector<int>& nums, int target) {
int leftindex=binarySearch(nums,target,true);
int rightindex= binarySearch(nums,target, false)-1;
if(leftindex<=rightindex&&rightindex<nums.size()&&nums[leftindex]==target&&nums[rightindex]==target){
return {leftindex,rightindex};
}
return {-1,-1};
}
7.编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：
每行中的整数从左到右按升序排列。
每行的第一个整数大于前一行的最后一个整数。
bool searchMatrix(vector<vector<int>>& matrix, int target) {
int row=matrix.size();
int col=matrix[0].size();
int i=0,j=col-1;
while(i<row&&j>=0){
if(matrix[i][j]>target){
j--;
}else if(matrix[i][j]<target){
i++;
}else{
return true;
}
}
return false;
}
8.已知存在一个按非降序排列的整数数组 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 。
你必须尽可能减少整个操作步骤。
bool search(vector<int>& nums, int target) {
int len=nums.size();
if(len==0){
return false;
}
if(len==1){
return nums[0]==target;
}
int left=0;
int right=len-1;
while(left<right){
int mid=left+(right-left)/2;
if(nums[mid]==target){
return true;
}
if(nums[left]==nums[mid]&&nums[right]==nums[mid]){//为了判断出有一边的单调性
left++;
right--;
}else if(nums[left]<=nums[mid]){
if(nums[left]<=target&&nums[mid]>target){
right=mid-1;
}else{
left=mid+1;
}
}else{
if(nums[mid]<target&&nums[right]>=target){
left=mid+1;
}else{
right=mid-1;
}
}
}
return nums[left]==target;
}
9.已知一个长度为 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) 的算法解决此问题。
int findMin(vector<int>& nums) {
int len=nums.size();
int left=0;
int right=len-1;
while(left<right){
int mid=left+(right-left)/2;
if(nums[mid]<nums[right]){
right=mid;
}else{
left=mid+1;
}
}
return nums[left];
}
10.已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,4,4,5,6,7] 在变化后可能得到：
若旋转 4 次，则可以得到 [4,5,6,7,0,1,4]
若旋转 7 次，则可以得到 [0,1,4,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 ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
你必须尽可能减少整个过程的操作步骤。
int findMin(vector<int>& nums) {
int len=nums.size();
int left=0;
int right=len-1;
while(left<right){
int mid=left+(right-left)/2;
if(nums[right]>nums[left]){
return nums[left];
}
if(nums[right]<nums[mid]){
left=mid+1;
}else if(nums[right]>nums[mid]){
right=mid;
}else{
right-=1;//因为不能判断是左是右，可以先忽略一边的数，直接前进
}
}
return nums[left];
}
1132
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
