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];
}