BINARY SEARCH

BINARY SEARCH BINARY SEARCH

int search(vector<int>& nums, int target) int search(vector<int>& nums, int target)
{ {
int n= [Link](); return search(nums,0,[Link]()-1,target);
int low =0; }
int high = n-1; int search(vector<int>& nums, int low, int high,
while(low<=high) int target)
{ {
int mid = (low+high)/2;
if(target==nums[mid]) return mid; if(low>high) return -1;
else if(target>nums[mid]) low=mid+1; int mid = (low+high)/2;
else high = mid-1; if(nums[mid]==target) return mid;
} else if(nums[mid]>target) return
return -1; search(nums,low,mid-1,target);
} else return search(nums,mid+1,high,target);
}

time complexity is O(logN) time complexity is O(logN)

UPPER BOUND LOWER BOUND

int upperBound(vector<int> &arr, int x, int n) int lowerBound(vector<int> arr, int n, int x)
{ { int low=0;
int low =0; int high = n-1;
int high = n-1; int ans =N;
int ans=n; while(low<=high)
while(low<=high) {
{ mid=(low+high)/2;
int mid = (low+high)/2; if(x<=arr[mid])
if(arr[mid]>x) {
{ ans=mid;
ans = mid; high = mid-1;
high = mid-1; }
} else low=mid+1;
else low=mid+1; }
} return ans;
return ans; }
}
 Search Insert Position

int searchInsert(vector<int>& arr, int m)

{
int low =0;
int n = [Link]();
int high = n-1;
int ans=n;
while(low<=high)
{
int mid = (low+high)/2;
if(arr[mid]>=m)
{

ans=mid;
high =mid-1;
}
else
{
low = mid+1;
}
}
return ans;
}

FLOOR AND CEIL

int floor(vector<int> &a, int n, int x)
{
int low =0;
int high =n-1;
int ans =-1;
while(low<=high)
{
int mid= (low+high)/2;
if(a[mid]<=x)
{
 ans = a[mid];
low = mid+1;
}
else high = mid-1;
}
return ans;
}
int ceil(vector<int> &a, int n, int x)
{
int low =0;
int high = n-1;
int ans =-1;
while(low <= high)
{
int mid = (low+high)/2;
if(a[mid]>=x)
{
ans = a[mid];
high=mid-1;
}
else
{
low = mid+1;
}
}
return ans;
}
pair<int, int> getFloorAndCeil(vector<int> &a, int n, int x)
{
int f= floor(a,n,x);
int c = ceil(a,n,x);
return {f,c};
}

First and Last Position of an Element In Sorted Array

vector<int> searchRange(vector<int>& nums, int target) int first(vector<int>& arr, int n, int k)
 { {
int left=0; int low =0;
int right = [Link]()-1; int high = n-1;
vector<int>ans={-1,-1}; int res=-1;
while(left<= right) while(low<=high)
{ {
if(nums[left]==target && ans[0]==-1)
int mid = (low+high)/2;
{
if(arr[mid]==k)
ans[0]=left;
{
}
res=mid;
if(nums[right]==target && ans[1]==-1)
high = mid-1;
{
}
ans[1]=right;
} else if(arr[mid]>k)
if(nums[left]<target) left++; {
else right--; high = mid-1;
} }
return ans; else low= mid+1;
} }
return res;
}
int last(vector<int>& arr, int n, int k)
time complexity of your code is O(N)
{
space complexity remains O(1)
int low =0;
int high = n-1;
int res =-1;
while (low<=high)
{
int mid = (low+high)/2;
if(arr[mid]==k)
{
res=mid;
low=mid+1;
}
else if(arr[mid]>k)
{
high=mid-1;
}
else low=mid+1;
}
 return res;
}
pair<int, int>
firstAndLastPosition(vector<int>& arr,
int n, int k)
{
int f=first(arr,n,k);
int l=last(arr,n,k);
return {f,l};
}
O(log N)
O(1)

Search In Rotated Sorted Array

int search(vector<int>& nums, int target) int search(vector<int>& arr, int n, int k)
{ {
for (int i = 0; i < [Link](); i++) int low=0,high=n-1;
{ while(low<=high)
if (nums[i] == target) {
{ int mid= (low+high)/2;
return i;
if(arr[mid]==k)
}
return mid;
}
if (arr[low]<=arr[mid])
return -1;
{
}
if ((arr[low]<=k) &&
(k<=arr[mid]))
{
high=mid-1;
}
else
{
low =mid +1;
}
}
else
{
 if((arr[mid]<=k) &&
(k<=arr[high]))
{
low=mid+1;
}
else
{
high =mid -1;
}
}

}
return -1;
}
99
10 11 1 2 3 4 5 6 9
8 11
3 5 7 8 9 10 11 2

Search in Rotated Sorted Array II

bool bool search(vector<int>& nums, int target)
searchInARotatedSortedArrayII(vecto {
r<int>&A,int key) int n = [Link]();
{ int low =0;
int n = [Link](); int high =n-1;
for(int i=0;i<n;i++) while(low<=high)
{
{
int mid =(low+high)/2;
if (A[i]==key) return true;
if(nums[mid]==target) return true;
}
if(nums[low]==nums[mid] && nums[mid]==nums[high])
return false;
{
}
low++;high--;
continue;
}
if(nums[low]<=nums[mid])
{
if(nums[low]<=target && nums[mid]>=target)
{
high = mid-1;
}
else low=mid+1;
 }
else
{
if(nums[mid]<=target && nums[high]>=target)
{
low = mid+1;
}
else high = mid-1;
}
}
return false;
}

Find Minimum in Rotated Sorted Array

int findMin(vector<int>& nums) int findMin(vector<int>& nums)

{ {
int n =[Link](); int low=0;
int minm=INT_MAX; int n = [Link]();
int high = n-1;
for(int i=0;i<n;i++) int ans = INT_MAX;
{ while(low<=high)
if(nums[i]<minm)
{
{
int mid= (low+high)/2;
minm=min(minm, nums[i]);
if(nums[low]<=nums[high])
} {
} ans = min(ans,nums[low]);
return minm; }
} if(nums[low]<=nums[mid])
{
ans = min(ans,nums[low]);
low=mid+1;
}
else
{
ans = min(ans,nums[mid]);
high = mid-1;
 }
}
return ans;
}

Find out how many times has an array is rotated

int findKRotation(vector<int> &arr) int findKRotation(vector<int> &arr)
{ {
int n = [Link](); int low =0;
int ans =arr[0]; int n = [Link]();
int res=0; int high = n-1;
for(int i =1; i<n; i++) int ans =INT_MAX;
{ int index=-1;
if(ans>arr[i]) while(low<=high)
{ {
ans=arr[i]; int mid =(low+high)/2;
res=i; if(arr[low]<=arr[high])
} {
} if(arr[low]<ans)
return res; {
} ans=arr[low];
index = low;
}
break;
}
if(arr[low]<=arr[mid])
{
if(ans>arr[low])
{
ans = arr[low];
index=low;
}
low= mid+1;
}
else
{
if(ans>arr[mid])
{
 ans = arr[mid];
index=mid;
}
high = mid-1;
}
}
return index;
}

int #include <bits/stdc++.h>

singleNonDuplicate(vector using namespace std;
<int>& arr) int singleNonDuplicate(vector<int>& arr)
{ {
int n = [Link](); int n = [Link]();
int cnt=0; if (n == 1) return arr[0];
int i=0; if (arr[0] != arr[1]) return arr[0];
while(i<n) if (arr[n - 1] != arr[n - 2]) return arr[n - 1];
{ int low = 1, high = n - 2;
while (low <= high)
if(arr[i]!=arr[i+1]) {
{ int mid = (low + high) / 2;
return arr[i]; if (arr[mid] != arr[mid + 1] && arr[mid] != arr[mid - 1])
} {
i=i+2; return arr[mid];
} }
} if ((mid % 2 == 1 && arr[mid] == arr[mid - 1])
|| (mid % 2 == 0 && arr[mid] == arr[mid + 1]))
{
low = mid + 1;
}
else
{
high = mid - 1;
}
}
return -1;
}
int findPeakElement(vector<int> &arr) int findPeakElement(vector<int> &arr)
{ {
int n = [Link](); int n = [Link]();
if(n==1) return 0; if (n == 1)
if (arr[0] > arr[1]) {
{ return 0;
return 0; }
} if (arr[0] > arr[1])
if (arr[n - 1] > arr[n - 2]) {
{ return 0;
return n - 1; }
} if (arr[n - 1] > arr[n - 2])
for(int i = 1;i<=n-2;i++) {
{ return n - 1;
}
if((arr[i]>arr[i-1])&&(arr[i]>arr[i+1])) int low = 1;
{ int high = n - 2;
return i; while (low <= high) {
} int mid = low + (high - low) / 2;
} if (arr[mid] > arr[mid - 1] && arr[mid] >
return -1; arr[mid + 1])
} {
return mid;
Time Complexity: O(N), N = size of the }
given array. else if (arr[mid] > arr[mid - 1])
Reason: We are traversing the entire {
array. low = mid + 1;
}
Space Complexity: O(1) as we are not else
using any extra space. {
high = mid - 1;
}
}
return -1;
}
 Square root of s a number
int floorSqrt(int n) int floorSqrt(int n)
{ {
if (n == 0 || n == 1) int low =1;
{ int high = n;
return n; while(low<=high)
} {
int ans = 1; int mid = (low+high )/2;
for (int i = 1; i <= n; ++i) int val = mid*mid;
{ if(val<=n)
int val = i * i; {
if (val > n) low = mid+1;
{ }
break; else
} {
ans = i; high = mid-1;
} }
return ans; }
} return high;
}

Nth root
int power(int base, int exp) int func(int mid, int n, int m)
{ {
int result = 1; long long ans = 1;
while (exp > 0) for (int i = 1; i <= n; ++i)
{ {
if (exp % 2 == 1) ans *= mid;
{ if (ans > m)
result = result * base; {
} return 2;
base =base* base; }
exp =exp/2; }
} if (ans == m)
return result; {
} return 1;
int NthRoot(int n, int m) }
{ return 0;
for (int i = 1; i <= m; i++) }
{
int v = power(i, n); int NthRoot(int n, int m)
if (v == m) {
{ if (n == 1)
return i; {
} return m;
else if (v > m) }
{
break; int low = 1;
} int high = m;
} while (low <= high)
return -1; {
} int mid = low + (high -
low) / 2;
int midN = func(mid, n, m);
if (midN == 1)
{
return mid;
}
else if (midN == 2)
{
high = mid - 1;
}
else
{
low = mid + 1;
}
}
return -1;
}

Median of two sorted array

double median(vector<int>& a, vector<int>& b)
{
int n = [Link]();
int m = [Link]();
int left = 0;
int low = a[left];
int right = 0;
int high = b[right];
vector<int> ans;
while (left < n && right < m)
{
if (a[left] <= b[right])
{
ans.push_back(a[left]);
left++;
}
else
{
ans.push_back(b[right]);
right++;
}
}
while (left < n)
{
ans.push_back(a[left]);
left++;
}
while (right < m)
{
ans.push_back(b[right]);
right++;
}
int vs = [Link]();
if (vs % 2 == 0)
{
int j = vs / 2;
return double((ans[j] + ans[j - 1]) / 2.0);
}
else
 {
int j = vs / 2;
return double(ans[j]);
}
}