├── Algorithms
    ├── Boyer Mores Voting Algorithm.cpp
    ├── Juggling Algorithm.cpp
    ├── Kadane's Algorithm.cpp
    └── Mores Voting Algorithm.cpp
├── Array
    ├── Complement.cpp
    ├── Find all missing numbers from a given sorted array.cpp
    ├── Find all missing numbers from a given unsorted array.cpp
    ├── Find the Missing Number.cpp
    ├── Find triplets with zero sum.cpp
    ├── Largest subarray with 0 sum.cpp
    ├── Lower Bound.cpp
    ├── Majority Element.cpp
    ├── Majority Element2.cpp
    ├── Merge Without Extra Space.cpp
    ├── Minimum Sum of Four Digit Number After Splitting Digits.cpp
    ├── Move all zeros to the end of array.cpp
    ├── Remove duplicate elements from sorted Array 2.cpp
    ├── Remove duplicate elements from sorted Array.cpp
    ├── Remove duplicate elements from unsorted Array.cpp
    ├── Rotate Array by d Elements.cpp
    ├── Subarrays with sum K.cpp
    └── Two Sum.cpp
├── Data Structures and Algorithms.jpeg
├── Errors.png
├── Matrix
    ├── Pascal's Triangles Nth Row.cpp
    └── Spiral Matrix.cpp
├── README.md
├── Recursion
    └── Repetitive Addition Of Digits.cpp
├── Searching
    ├── Binary Searching.cpp
    ├── Ceil in a Sorted Array.cpp
    ├── Count 1’s in a sorted binary array.cpp
    ├── Exponential Searching.cpp
    ├── Find K Rotation.cpp
    ├── Find Minimum in Rotated Sorted Array with Distinct Elements.cpp
    ├── Find Minimum in Rotated Sorted Array with Duplicates.cpp
    ├── Find Smallest Letter Greater Than Target.cpp
    ├── Find in Mountain Array.cpp
    ├── Find position of an element in a sorted array of infinite numbers.cpp
    ├── First and last occurrences of X Modularly.cpp
    ├── First and last occurrences of X.cpp
    ├── Floor in a Sorted Array.cpp
    ├── Interpolation Searching.cpp
    ├── Jump Searching.cpp
    ├── Linear Searching.cpp
    ├── Peak element.cpp
    ├── Search in Rotated Sorted Array with Duplicates.cpp
    └── Search in a Rotated Array with Distinct Elements.cpp
├── Sorting
    ├── Bubble Sorting Optimisefd for O(N) Sorted Elements.cpp
    ├── Bubble Sorting.cpp
    ├── Count Sorting.cpp
    ├── Defense of a Kingdom.cpp
    ├── Insertion Sorting.cpp
    ├── Selection Sorting.cpp
    └── Sorting with Comparators.cpp
├── String
    ├── Complement.cpp
    ├── Count Occurences of Anagrams.cpp
    ├── Palindrome String.cpp
    └── Using get and getline.cpp
└── Time complex.png


/Algorithms/Boyer Mores Voting Algorithm.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Approach - Boyer Mores Voting Algorithm
 3 | Time Complexity : O(N)
 4 | Space Complexity : O(1)
 5 | */
 6 | #include<bits/stdc++.h>
 7 | using namespace std;
 8 | void majorityElement(int arr[], int size){
 9 |     int count1 = 0;
10 |     int count2 = 0;
11 |     int candidate1 = 0;
12 |     int candidate2 = 0;
13 |     for(int i=0; i<size; i++){
14 |         if(count1 == 0){
15 |             candidate1 = arr[i];
16 |         }else if(count2 == 0){
17 |             candidate2 = arr[i];
18 |         }else if(candidate1 == arr[i]){
19 |             count1++;
20 |         }else if(candidate2 == arr[i]){
21 |             count2++;
22 |         }else{
23 |             count1--;
24 |             count2--;
25 |         }
26 |     }
27 |     vector <int> v;
28 |     count1 = 0;
29 |     count2 = 0;
30 |     for(int i=0; i<size; i++){
31 |         if(arr[i] == candidate1){
32 |             count1++;
33 |         }else if(arr[i] == candidate2){
34 |             count2++;
35 |         }
36 |     }
37 |     if(count1 > size/3){
38 |         v.push_back(candidate1);
39 |     }
40 |     if(count2 > size/3){
41 |         v.push_back(candidate2);
42 |     }
43 |     if(v.size() == 0){
44 |         cout<<"-1";
45 |     }
46 |     for(int i=0; i<v.size(); i++){
47 |         cout<<v[i]<<" ";
48 |     }
49 | }
50 | 
51 | int main(){
52 |     int arr[] = {10, 10, 20, 30, 10, 10};
53 |     int n = sizeof(arr) / sizeof(arr[0]);
54 |     majorityElement(arr, n);
55 |     return 0;
56 | }


--------------------------------------------------------------------------------
/Algorithms/Juggling Algorithm.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Juggling Algorithm
 3 | Time Complexity : O(N)
 4 | Space Complexity : O(1)
 5 | */
 6 | #include<bits/stdc++.h>
 7 | using namespace std;
 8 | int findgcd(int a, int b){
 9 |     if(b == 0){
10 |         return a;
11 |     }else{
12 |         return findgcd(b, a % b);
13 |     }
14 | }
15 | 
16 | void rotateArray(int arr[], int size, int rotateBy){
17 |     int gcd = findgcd(size, rotateBy);
18 |     for(int i=0; i<gcd; i++){
19 |         int temp = arr[i];
20 |         int j = i;
21 |         while(true){
22 |             int k = j + rotateBy;
23 |             if(k >= size){
24 |                 k = k - size;
25 |             }
26 |             if(k == i){
27 |                 break;
28 |             }
29 |             arr[j] = arr[k];
30 |             j = k;
31 |         }
32 |         arr[j] = temp;
33 |     }
34 |     for(int i=0; i<size; i++){
35 |         cout<<arr[i]<<" ";
36 |     }
37 | }
38 | 
39 | int main(){
40 |     int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
41 |     int n = sizeof(arr) / sizeof(arr[0]);
42 |     int d = 3;
43 |     d = d % n;
44 |     rotateArray(arr, n, d);
45 |     return 0;
46 | }


--------------------------------------------------------------------------------
/Algorithms/Kadane's Algorithm.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Kadane's Algorithm
 3 | Time Complexity : O(N)
 4 | Space Complexity : O(1)
 5 | */
 6 | #include<bits/stdc++.h>
 7 | using namespace std;
 8 | 
 9 | int maxSubarraySum(int arr[], int size){
10 |     int curr_sum = 0;
11 |     int max_sum = INT_MIN;
12 |     for(int i=0; i<size; i++){
13 |         curr_sum = curr_sum + arr[i];
14 |         if(curr_sum>max_sum){
15 |             max_sum = curr_sum;
16 |         }
17 |         if(curr_sum<0){
18 |             curr_sum = 0;
19 |         }
20 |     }
21 |     return max_sum;
22 | }
23 | 
24 | int main(){
25 |     int arr[] = {1, 2, -3, 4, 5, 6, -7, -8, 9};
26 |     int n = sizeof(arr) / sizeof(arr[0]);
27 |     cout<<maxSubarraySum(arr, n);
28 |     return 0;
29 | }


--------------------------------------------------------------------------------
/Algorithms/Mores Voting Algorithm.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Approach - Mores Voting Algorithm
 3 | Time Complexity : O(N)
 4 | Space Complexity : O(1)
 5 | */
 6 | int majorityElement(int arr[], int size){
 7 |     int count = 0;
 8 |     int candidate = 0;
 9 |     for(int i=0; i<size; i++){
10 |         if(count == 0){
11 |             candidate = arr[i];
12 |         }
13 |         if(candidate == arr[i]){
14 |             count++;
15 |         }else{
16 |             count--;
17 |         }
18 |     }
19 |     count = 0;
20 |     for(int i=0; i<size; i++){
21 |         if(arr[i] == candidate){
22 |             count++;
23 |         }
24 |     }
25 |     if(count > size/2){
26 |         return candidate;
27 |     }else{
28 |         return -1;
29 |     }
30 | }
31 | 
32 | int main(){
33 |     int arr[] = {3, 1, 3, 3, 2};
34 |     int n = sizeof(arr) / sizeof(arr[0]);
35 |     cout<<majorityElement(arr, n);
36 |     return 0;
37 | }


--------------------------------------------------------------------------------
/Array/Complement.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Complement - https://practice.geeksforgeeks.org/problems/complement3911/1
 3 | Approach - Using a window to counter number of zero's with one's (Using kadanes Algorithm)
 4 | Time Complexity : O(N)
 5 | Space Complexity : O(1)
 6 | */
 7 | 
 8 | #include<bits/stdc++.h>
 9 | using namespace std;
10 | vector<int> findRange(string str, int size){
11 |     int l = 0;
12 |     int ans_l, ans_r;
13 |     int maxDiff = 0;
14 |     int zeroCount = 0, oneCount = 0;
15 |     for(int i=0; i<size; i++){
16 |         if(str[i] == '0'){
17 |             zeroCount++;
18 |         }
19 |         else oneCount++;
20 |            
21 |         if(zeroCount < oneCount){
22 |             l = i + 1;
23 |             zeroCount = 0;
24 |             oneCount = 0;
25 |         }else{
26 |             if(zeroCount - oneCount > maxDiff) {
27 |                 ans_l = l;
28 |                 ans_r = i;
29 |                 maxDiff = zeroCount - oneCount;
30 |             }
31 |         }
32 |     }
33 |     if(maxDiff == 0){
34 |         return {-1};
35 |     }
36 |     return {ans_l + 1, ans_r + 1};
37 | }
38 | 
39 | int main(){
40 |     string str = "111100010";
41 |     int n = sizeof(str) / sizeof(str[0]);
42 |     vector<int> v = findRange(str, n);
43 |     cout<<v[0]<<" "<<v[1]<<endl;
44 |     return 0;
45 | }


--------------------------------------------------------------------------------
/Array/Find all missing numbers from a given sorted array.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Find the Missing Number
 3 | Approach - Keeping Track of Temp(Temparary Index)
 4 | Time Complexity : O(N)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | void printMissingElements(int arr[], int size){
10 |     int temp = 0;
11 |     for(int i=arr[0]; i<=arr[size - 1]; i++){
12 |         if(arr[temp] == i){
13 |             temp++;
14 |         }else{
15 |             cout<<i<<" ";
16 |         }
17 |     }
18 | }
19 | 
20 | int main(){
21 |     int arr[] = {5, 10, 11, 13};
22 |     int n = sizeof(arr) / sizeof(arr[0]);
23 |     printMissingElements(arr, n);
24 |     return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/Array/Find all missing numbers from a given unsorted array.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Find the Missing Number i`n Unsorted Array
 3 | Approach - Keeping Track of Temp(Temparary Index)
 4 | Time Complexity : O(N)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | void printMissingElements(int arr[], int size){
10 |     for(int i=0; i<size; i++){
11 |         int temp = abs(arr[i]) - 1;
12 |         if(arr[temp] > 0){
13 |             arr[temp] *= -1;
14 |         }
15 |     }
16 |     for(int i=0; i<size; i++){
17 |         if(arr[i] > 0){
18 |             cout<<i+1<<" ";
19 |         }
20 |     }
21 | }
22 | 
23 | int main(){
24 |     int arr[] = {4, 3, 2, 7, 8, 2, 3, 1};
25 |     int n = sizeof(arr) / sizeof(arr[0]);
26 |     printMissingElements(arr, n);
27 |     return 0;
28 | }


--------------------------------------------------------------------------------
/Array/Find the Missing Number.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Find the Missing Number
 3 | Approach - Reverse
 4 | Time Complexity : O(N logN)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | int getMissingNo(int arr[], int size){
10 |     sort(arr, arr + size);
11 |     for(int i=0; i<size; i++){
12 |         if(arr[i] != i){
13 |             return i;
14 |         }
15 |     }
16 |     return n;
17 | }
18 | 
19 | int main(){
20 |     int arr[] = {1, 2, 4, 6, 3, 7, 8};
21 |     int n = sizeof(arr) / sizeof(arr[0]);
22 |     cout<< getMissingNo(arr, n);
23 |     return 0;
24 | }
25 | 
26 | /* 
27 | Find the Missing Number
28 | Approach - Using Sum of n natural numbers
29 | Time Complexity : O(N)
30 | Space Complexity : O(1)
31 | */
32 | #include<bits/stdc++.h>
33 | using namespace std;
34 | int getMissingNo(int arr[], int size){
35 |     int totalSum = (size * (size + 1)) / 2;
36 |     for(int i=0; i<size; i++){
37 |         totalSum -= arr[i];
38 |     }
39 |     return totalSum;
40 | }
41 | 
42 | int main(){
43 |     int arr[] = {1, 2, 4, 6, 3, 7, 8};
44 |     int n = sizeof(arr) / sizeof(arr[0]);
45 |     cout<< getMissingNo(arr, n);
46 |     return 0;
47 | }
48 | 


--------------------------------------------------------------------------------
/Array/Find triplets with zero sum.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Find triplets with zero sum 
 3 | Approach - Using Sorting and a little Trick
 4 | Time Complexity : O(N^2)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | bool findTriplets(int arr[], int size){
10 |     sort(arr, arr + size);
11 |     int c = size - 1;
12 |     while(arr[c] != 0){
13 |         int a = 0;
14 |         int b = c - 1;
15 |         while(a < b){
16 |             if(arr[a] + arr[b] + arr[c] == 0){
17 |                 return true;
18 |             }else if(arr[a] + arr[b] + arr[c] > 0){
19 |                 b--;
20 |             }else{
21 |                 a++;
22 |             }
23 |         }
24 |     }
25 |     return false;
26 | }
27 | 
28 | int main(){
29 |     int arr[] = {0, -1, 2, -3, 1};
30 |     int n = sizeof(arr) / sizeof(arr[0]);
31 |     cout<<findTriplets(arr, n);
32 |     return 0;
33 | }


--------------------------------------------------------------------------------
/Array/Largest subarray with 0 sum.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Largest subarray with 0 sum
 3 | Approach - Using Hash Map
 4 | Time Complexity : O(N)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | int findSubArraySum(int arr[], int size){
10 |     int count = 0;
11 |     int maxCount = 0;
12 |     int sum = 0;
13 |     unordered_map <int, int> mpp;
14 |     for(int i=0; i<size; i++){
15 |         sum += arr[i];
16 |         if(sum == 0){
17 |             maxCount = max(maxCount, i + 1);
18 |         }
19 |         if(mpp.find(sum) != mpp.end()){
20 |             maxCount = max(maxCount, i - mpp[sum]);
21 |         }else{
22 |             mpp[sum] = i;
23 |         }
24 |     }
25 |     return maxCount;
26 | }
27 | 
28 | int main(){
29 |     int arr[] = {15, -2, 2, -8, 1, 7, 10, 23};
30 |     int n = sizeof(arr) / sizeof(arr[0]);
31 |     cout<< findSubArraySum(arr, n);
32 |     return 0;
33 | }


--------------------------------------------------------------------------------
/Array/Lower Bound.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | lower Bound
 3 | Approach - Using Binary search algorithm
 4 | Time Complexity : O(N) or worst case O(N^2)
 5 | Space Complexity : O(N)
 6 | */
 7 | 
 8 | #include<bits/stdc++.h>
 9 | using namespace std;
10 | 
11 | int lowerBound(int arr[], int size, int x){
12 |   int lb = -1;
13 |   int start = 0;
14 |   int end = size - 1;
15 |   while(start <= end){
16 |     int mid = start + (end - start) / 2;
17 |     if(arr[mid] > x){
18 |       end = mid - 1;
19 |     }
20 |     else{
21 |       lb = arr[mid];
22 |       start = mid + 1;
23 |     }
24 |   }
25 |   return lb;
26 | }
27 | 
28 | int main(){
29 |   int arr[] = {-2, 3, 4, -1, 5, -12, 6, 1, 3};
30 |   int n = sizeof(arr)/sizeof(int);
31 | 
32 |   // Lower bound is applied on shorted array
33 |   sort(arr, arr + n);
34 | 
35 |   int x = -3;
36 |   int lb = lowerBound(arr, n, x);
37 |   cout<<lb;
38 |   return 0;
39 | }


--------------------------------------------------------------------------------
/Array/Majority Element.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Majority Element > N/2
 3 | Approach - Using unordered_map
 4 | Time Complexity : O(N) or worst case O(N^2)
 5 | Space Complexity : O(N)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | 
10 | int majorityElement(int arr[], int size){
11 |     unordered_map <int, int> mpp;
12 |     for(int i=0; i<size; ++i){
13 |         int count = ++mpp[arr[i]];
14 |         if(count > size/2){
15 |             return arr[i];
16 |         }
17 |     }
18 |     return -1;
19 | }
20 | 
21 | int main(){
22 |     int arr[] = {3, 1, 3, 3, 2};
23 |     int n = sizeof(arr) / sizeof(arr[0]);
24 |     cout<<majorityElement(arr, n);
25 |     return 0;
26 | }
27 | /* 
28 | Majority Element > N/2
29 | Approach - Mores Voting Algorithm
30 | Time Complexity : O(N)
31 | Space Complexity : O(1)
32 | */
33 | int majorityElement(int arr[], int size){
34 |     int count = 0;
35 |     int candidate = 0;
36 |     for(int i=0; i<size; i++){
37 |         if(count == 0){
38 |             candidate = arr[i];
39 |         }
40 |         if(candidate == arr[i]){
41 |             count++;
42 |         }else{
43 |             count--;
44 |         }
45 |     }
46 |     count = 0;
47 |     for(int i=0; i<size; i++){
48 |         if(arr[i] == candidate){
49 |             count++;
50 |         }
51 |     }
52 |     if(count > size/2){
53 |         return candidate;
54 |     }else{
55 |         return -1;
56 |     }
57 | }
58 | 
59 | int main(){
60 |     int arr[] = {3, 1, 3, 3, 2};
61 |     int n = sizeof(arr) / sizeof(arr[0]);
62 |     cout<<majorityElement(arr, n);
63 |     return 0;
64 | }
65 | 


--------------------------------------------------------------------------------
/Array/Majority Element2.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Majority Element > N/2
 3 | Approach - Using unordered_map
 4 | Time Complexity : O(N) or worst case O(NlogN)
 5 | Space Complexity : O(N)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | void majorityElement(int arr[], int size){
10 |     unordered_map <int, int> mpp;
11 |     vector <int> v;
12 |     for(int i=0; i<size; ++i){
13 |         int count = ++mpp[arr[i]];
14 |         if(count > size/3){
15 |             v.push_back(arr[i]);
16 |         }
17 |     }
18 |     for(int i=0; i<v.size(); ++i){
19 |         cout<<v[i]<<" ";
20 |     }
21 | }
22 | 
23 | int main(){
24 |     int arr[] = {10, 10, 20, 30, 10, 10};
25 |     int n = sizeof(arr) / sizeof(arr[0]);
26 |     majorityElement(arr, n);
27 |     return 0;
28 | }
29 | /* 
30 | Majority Element > N/2
31 | Approach - Boyer Mores Voting Algorithm
32 | Time Complexity : O(N)
33 | Space Complexity : O(1)
34 | */
35 | #include<bits/stdc++.h>
36 | using namespace std;
37 | void majorityElement(int arr[], int size){
38 |     int count1 = 0;
39 |     int count2 = 0;
40 |     int candidate1 = 0;
41 |     int candidate2 = 0;
42 |     for(int i=0; i<size; i++){
43 |         if(count1 == 0){
44 |             candidate1 = arr[i];
45 |         }else if(count2 == 0){
46 |             candidate2 = arr[i];
47 |         }else if(candidate1 == arr[i]){
48 |             count1++;
49 |         }else if(candidate2 == arr[i]){
50 |             count2++;
51 |         }else{
52 |             count1--;
53 |             count2--;
54 |         }
55 |     }
56 |     vector <int> v;
57 |     count1 = 0;
58 |     count2 = 0;
59 |     for(int i=0; i<size; i++){
60 |         if(arr[i] == candidate1){
61 |             count1++;
62 |         }else if(arr[i] == candidate2){
63 |             count2++;
64 |         }
65 |     }
66 |     if(count1 > size/3){
67 |         v.push_back(candidate1);
68 |     }
69 |     if(count2 > size/3){
70 |         v.push_back(candidate2);
71 |     }
72 |     if(v.size() == 0){
73 |         cout<<"-1";
74 |     }
75 |     for(int i=0; i<v.size(); i++){
76 |         cout<<v[i]<<" ";
77 |     }
78 | }
79 | 
80 | int main(){
81 |     int arr[] = {10, 10, 20, 30, 10, 10};
82 |     int n = sizeof(arr) / sizeof(arr[0]);
83 |     majorityElement(arr, n);
84 |     return 0;
85 | }
86 | 


--------------------------------------------------------------------------------
/Array/Merge Without Extra Space.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Merge Without Extra Space
 3 | Time Complexity : O((N+M)log(N+M))
 4 | Space Complexity : O(1)
 5 | */
 6 | #include<bits/stdc++.h>
 7 | using namespace std;
 8 | 
 9 | void merge(int arr1[], int arr2[], int n, int m){ 
10 |     int gap = ceil((float)(m + n) / 2);
11 |     while(gap > 0){
12 |         int i = 0;
13 |         int j = gap;
14 |         while(j < (m + n)){
15 |             if(j < n && arr1[i] > arr1[j]){
16 |                 swap(arr1[i], arr1[j]);
17 |             }else if(i < n && j >= n && arr1[i] > arr2[j - n]){
18 |                 swap(arr1[i], arr2[j - n]);
19 |             }else if(i >= n && j >= n && arr2[i - n] > arr2[j - n]){
20 |                 swap(arr2[i - n], arr2[j - n]);
21 |             }
22 |             i++;
23 |             j++;
24 |         }
25 |         if(gap == 1){
26 |             gap = 0;
27 |         }else{
28 |             gap = ceil((float)gap / 2);
29 |         }
30 |     }
31 | }
32 | 
33 | int main(){
34 |     int arr1[] = {1, 3, 5, 7};
35 |     int arr2[] = {0, 2, 6, 8, 9};
36 |     int n, m;
37 |     n = sizeof(arr1) / sizeof(arr1[0]);
38 |     m = sizeof(arr2) / sizeof(arr2[0]);
39 |     merge(arr1, arr2, n, m);
40 |     for(int i=0; i<n; i++){
41 |         cout<<arr1[i]<<" ";
42 |     }
43 |     for (int i=0; i<m; i++){
44 |         cout<<arr2[i]<<" ";
45 |     }
46 |     cout<<endl;
47 |     return 0;
48 | }


--------------------------------------------------------------------------------
/Array/Minimum Sum of Four Digit Number After Splitting Digits.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Minimum Sum of Four Digit Number After Splitting Digits 
 3 | Time Complexity : O(N)
 4 | Space Complexity : O(1)
 5 | */
 6 | #include<bits/stdc++.h>
 7 | using namespace std;
 8 | 
 9 | int minimumSum(int num) {
10 |     int arr[4];
11 |     for(int i=0; i<4; i++){
12 |         arr[i] = num%10;
13 |         num = num/10;
14 |     }
15 |     sort(arr, arr+4);
16 |     int a = arr[0] * 10 + arr[2];
17 |     int b = arr[1] * 10 + arr[3];
18 |     return a + b;
19 | }
20 | 
21 | int main(){
22 |     int num = 2932;
23 |     cout<<minimumSum(num);
24 |     return 0;
25 | }


--------------------------------------------------------------------------------
/Array/Move all zeros to the end of array.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Move all zeros to the end of array
 3 | Approach - Using Indexing method
 4 | Time Complexity : O(N)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | 
10 | void pushZerosToEnd(int arr[], int size){
11 |     int count = 0;
12 | 	for(int i=0; i<size; i++){
13 | 	    if(arr[i] != 0){
14 | 	        arr[count++] = arr[i];
15 | 	    }
16 | 	}
17 | 	while(count < size){
18 | 	    arr[count++] = 0;
19 | 	}
20 |     for(int i=0; i<size; i++){
21 |         cout<<arr[i]<<" ";
22 |     }
23 | }
24 | 
25 | int main(){
26 |     int arr[] = {1, 0, 2, 3, 0, 0, 4, 0};
27 |     int n = sizeof(arr) / sizeof(arr[0]);
28 |     pushZerosToEnd(arr, n);
29 |     return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/Array/Remove duplicate elements from sorted Array 2.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Remove duplicates such that each unique element appears at most twice
 3 | Input: arr = [1 1 1 2 2 3 4 5 5 5]
 4 | Output: arr = [1 1 2 2 3 4 5 5]
 5 | 
 6 | Time Complexity : O(N)
 7 | Space Complexity : O(1)
 8 | */
 9 | 
10 | #include<bits/stdc++.h>
11 | using namespace std;
12 | int removeDuplicates(int arr[], int size){
13 |     if(size <= 2){
14 |         return size;
15 |     }
16 |     int newArrayCount = 2;
17 |     for(int i=2; i<size; i++){
18 |         if (arr[i] != arr[newArrayCount - 2]){
19 |             arr[newArrayCount] = arr[i];
20 |             newArrayCount++;
21 |         }
22 |     }
23 |     return newArrayCount;
24 | }
25 | 
26 | int main(){
27 |     int arr[] = {1, 1, 1, 2, 2, 3, 4, 5, 5, 5};
28 |     int n = sizeof(arr) / sizeof(arr[0]);
29 |     int N = removeDuplicates(arr, n);
30 |     for(int i=0; i<N; i++){
31 |         cout<<arr[i]<<" ";
32 |     }
33 |     return 0;
34 | }


--------------------------------------------------------------------------------
/Array/Remove duplicate elements from sorted Array.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Remove duplicate elements from sorted Array
 3 | Approach - Just maintain a separate index for same array
 4 | Time Complexity : O(N)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | int removeDuplicates(int arr[], int size){
10 |     if(size == 0 || size == 1){
11 |         return size;
12 |     }
13 |     int j = 0;
14 |     for(int i=0; i<size-1; i++){
15 |         if(arr[i] != arr[i+1]){
16 |             arr[j++] = arr[i];
17 |         }
18 |     }
19 |     arr[j++] = arr[size-1];
20 |     return j;
21 | }
22 | 
23 | int main(){
24 |     int arr[] = {10, 10, 20, 20, 30, 40, 50, 50};
25 |     int n = sizeof(arr) / sizeof(arr[0]);
26 |     int N = removeDuplicates(arr, n);
27 |     for(int i=0; i<N; i++){
28 |         cout<<arr[i]<<" ";
29 |     }
30 |     return 0;
31 | }


--------------------------------------------------------------------------------
/Array/Remove duplicate elements from unsorted Array.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Remove duplicate elements from unsorted Array
 3 | Approach - Using unordered_map for hashing
 4 | Time Complexity : O(N)
 5 | Space Complexity : O(N)
 6 | */
 7 | /* 
 8 | Remove duplicate elements from unsorted Array
 9 | Approach - Using unordered_map for hashing
10 | Time Complexity : O(N)
11 | Space Complexity : O(N)
12 | */
13 | #include<bits/stdc++.h>
14 | using namespace std;
15 | void removeDuplicates(int arr[], int size){
16 |     map<int, int> mpp;
17 |     for(int i=0; i<size; i++){
18 |         ++mpp[arr[i]];
19 |     }
20 |     for(auto it : mpp){
21 |         cout<<it.first<<" ";
22 |     }
23 | }
24 | 
25 | int main(){
26 |     int arr[] = {10, 20, 10, 30, 20, 40, 50, 50};
27 |     int n = sizeof(arr) / sizeof(arr[0]);
28 |     removeDuplicates(arr, n);
29 |     return 0;
30 | }


--------------------------------------------------------------------------------
/Array/Rotate Array by d Elements.cpp:
--------------------------------------------------------------------------------
  1 | /* 
  2 | Rotate Array by d Elements
  3 | Approach - Rotate one by one
  4 | Time Complexity : O(N * d)
  5 | Space Complexity : O(1)
  6 | */
  7 | #include<bits/stdc++.h>
  8 | using namespace std;
  9 | void rotateArray(int arr[], int size, int rotateBy){
 10 |     while(rotateBy--){
 11 |         int temp = arr[0];
 12 |         for(int i=0; i<size-1; i++){
 13 |             arr[i] = arr[i+1];
 14 |         }
 15 |         arr[size-1] = temp;
 16 |     }
 17 |     for(int i=0; i<size; i++){
 18 |         cout<<arr[i]<<" ";
 19 |     }
 20 | }
 21 | 
 22 | int main(){
 23 |     int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
 24 |     int n = sizeof(arr) / sizeof(arr[0]);
 25 |     int d = 3;
 26 |     rotateArray(arr, n, d);
 27 |     return 0;
 28 | }
 29 | 
 30 | /* 
 31 | Rotate Array by d Elements
 32 | Approach - Juggling Algorithm
 33 | Time Complexity : O(N)
 34 | Space Complexity : O(1)
 35 | */
 36 | #include<bits/stdc++.h>
 37 | using namespace std;
 38 | int findgcd(int a, int b){
 39 |     if(b == 0){
 40 |         return a;
 41 |     }else{
 42 |         return findgcd(b, a % b);
 43 |     }
 44 | }
 45 | 
 46 | void rotateArray(int arr[], int size, int rotateBy){
 47 |     int gcd = findgcd(size, rotateBy);
 48 |     for(int i=0; i<gcd; i++){
 49 |         int temp = arr[i];
 50 |         int j = i;
 51 |         while(true){
 52 |             int k = j + rotateBy;
 53 |             if(k >= size){
 54 |                 k = k - size;
 55 |             }
 56 |             if(k == i){
 57 |                 break;
 58 |             }
 59 |             arr[j] = arr[k];
 60 |             j = k;
 61 |         }
 62 |         arr[j] = temp;
 63 |     }
 64 |     for(int i=0; i<size; i++){
 65 |         cout<<arr[i]<<" ";
 66 |     }
 67 | }
 68 | 
 69 | int main(){
 70 |     int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
 71 |     int n = sizeof(arr) / sizeof(arr[0]);
 72 |     int d = 3;
 73 |     d = d % n;
 74 |     rotateArray(arr, n, d);
 75 |     return 0;
 76 | }
 77 | 
 78 | /* 
 79 | Rotate Array by d Elements
 80 | Approach - Reverse Array
 81 | Time Complexity : O(N)
 82 | Space Complexity : O(1)
 83 | */
 84 | #include<bits/stdc++.h>
 85 | using namespace std;
 86 | void rotateArray(int arr[], int size, int rotateBy){
 87 |     reverse(arr, arr + rotateBy);
 88 |     reverse(arr + rotateBy, arr + size);
 89 |     reverse(arr, arr + size);
 90 |     for(int i=0; i<size; i++){
 91 |         cout<<arr[i]<<" ";
 92 |     }
 93 | }
 94 | 
 95 | int main(){
 96 |     int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
 97 |     int n = sizeof(arr) / sizeof(arr[0]);
 98 |     int d = 3;
 99 |     rotateArray(arr, n, d);
100 |     return 0;
101 | }


--------------------------------------------------------------------------------
/Array/Subarrays with sum K.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Subarrays with sum K
 3 | Approach - Brute Force
 4 | Time Complexity : O(N^2)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | int findSubArraySum(int arr[], int size, int findNum){
10 |     int count = 0;
11 |     for(int i=0; i<size; i++){
12 |         int sum = 0;
13 |         for(int j=i; j<size; j++){
14 |             sum += arr[j];
15 |             if(sum == findNum){
16 |                 count++;
17 |             }
18 |         }
19 |     }
20 |     return count;
21 | }
22 | 
23 | int main(){
24 |     int arr[] = {10 , 2, -2, -20, 10};
25 |     int n = sizeof(arr) / sizeof(arr[0]);
26 |     int k = -10;
27 |     cout<< findSubArraySum(arr, n, k);
28 |     return 0;
29 | }
30 | 
31 | /* 
32 | Subarrays with sum K
33 | Approach - Using Hash Map
34 | Time Complexity : O(N)
35 | Space Complexity : O(1)
36 | */
37 | #include<bits/stdc++.h>
38 | using namespace std;
39 | int findSubArraySum(int arr[], int size, int findNum){
40 |     int sum = 0;
41 |     int count = 0;
42 |     unordered_map <int, int> mpp;
43 |     for(int i=0; i<size; i++){
44 |         sum += arr[i];
45 |         if(sum == findNum){
46 |             count++;
47 |         }
48 |         if(mpp.find(sum - findNum) != mpp.end()){
49 |             count += mpp[sum - k];
50 |         }
51 |         mpp[sum]++;
52 |     }
53 |     return count;
54 | }
55 | 
56 | int main(){
57 |     int arr[] = {10 , 2, -2, -20, 10};
58 |     int n = sizeof(arr) / sizeof(arr[0]);
59 |     int k = -10;
60 |     cout<< findSubArraySum(arr, n, k);
61 |     return 0;
62 | }


--------------------------------------------------------------------------------
/Array/Two Sum.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Two Sum / Key Pair Sum
 3 | Approach - Using HashMap
 4 | Time Complexity : O(N)
 5 | Space Complexity : O(N)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | bool hasArrayTwoCandidates(int arr[], int size, int x) {
10 | 	unordered_map<int, int> mpp;
11 | 	for(int i=0; i<size; i++){
12 | 	    int findNum = x - arr[i];
13 | 	    if(mpp.find(findNum) != mpp.end()){
14 | 	        return true;
15 | 	    }else{
16 |              mpp[arr[i]] = i;
17 |         }
18 | 	}
19 | 	return false;
20 | }
21 | 
22 | int main(){
23 |     int arr[] = {1, 2, 4, 3, 6};
24 |     int n = sizeof(arr) / sizeof(arr[0]);
25 |     int target = 10;
26 |     cout<< hasArrayTwoCandidates(arr, n, target);
27 |     return 0;
28 | }


--------------------------------------------------------------------------------
/Data Structures and Algorithms.jpeg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/deathook007/Data-Structures-and-Algorithms/2708de795ee2749c4ba479a99e1996a8a2a86271/Data Structures and Algorithms.jpeg


--------------------------------------------------------------------------------
/Errors.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/deathook007/Data-Structures-and-Algorithms/2708de795ee2749c4ba479a99e1996a8a2a86271/Errors.png


--------------------------------------------------------------------------------
/Matrix/Pascal's Triangles Nth Row.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Pascal's Triangles Nth Row
 3 | Time Complexity : O(N^2)
 4 | Space Complexity : O(1)
 5 | */
 6 | 
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | #define MOD 1000000007
10 | 
11 | vector<long long> pascalTriangle(int n){
12 |     vector<vector<long long>> ans(n);
13 |     for(int i=0; i<n; i++){
14 |         ans[i].resize(i + 1);
15 |         ans[i][0] = ans[i][i] = 1;
16 |            
17 |         for(int j=1; j<i; j++){
18 |             ans[i][j] = (ans[i - 1][j - 1] + ans[i - 1][j]) % MOD;
19 |         }
20 |     }
21 |     return ans[n - 1];
22 | }
23 | 
24 | void printAns(vector<long long> &ans){
25 |     for(auto &x : ans){
26 |         cout<<x<<" ";
27 |     }
28 |     cout<<"\n";
29 | }
30 | 
31 | int main(){
32 |     int n = 5;
33 |     auto ans = pascalTriangle(n);
34 |     cout<<n<<" th row of pascal's triangle is : ";
35 |     printAns(ans);
36 |     return 0;
37 | }


--------------------------------------------------------------------------------
/Matrix/Spiral Matrix.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Spiral Matrix
 3 | Time Complexity : O(NM)
 4 | Space Complexity : O(1)
 5 | */
 6 | 
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | vector<int> spirallyTraverse(vector<vector<int>> matrix){
10 |     vector<int> v;
11 |     int n = matrix.size();
12 |     int m = matrix[0].size();
13 |     int startRow = 0;
14 |     int endRow = n - 1;
15 |     int startColumn = 0;
16 |     int endColumn = m - 1;
17 |         
18 |     while(startRow <= endRow && startColumn <= endColumn){
19 |         for(int column = startColumn; column <= endColumn; column++){
20 |              v.push_back(matrix[startRow][column]);
21 |         }
22 |             
23 |         for(int row = startRow + 1; row <= endRow; row++){
24 |              v.push_back(matrix[row][endColumn]);
25 |         }
26 |             
27 |         for(int column = endColumn - 1; column >= startColumn; column--){
28 |             if(startRow == endRow){
29 |                 break;
30 |             } 
31 |             v.push_back(matrix[endRow][column]);
32 |         }
33 |             
34 |         for(int row = endRow - 1; row >= startRow + 1; row--){
35 |             if(startColumn == endColumn){
36 |                 break;
37 |             }  
38 |             v.push_back(matrix[row][startColumn]);
39 |         }
40 | 
41 |         startRow++;
42 |         endColumn--;
43 |         endRow--;
44 |         startColumn++;   
45 |     }
46 |     return v;
47 | }
48 | 
49 | int main(){
50 |     vector<vector<int>> matrix = {
51 |     {1, 2, 3, 4},
52 |     {5, 6, 7, 8},
53 |     {9, 10, 11, 12},
54 |     {13, 14, 15,16}
55 |     };
56 |     vector<int> v = spirallyTraverse(matrix);
57 |     for(int i = 0; i < v.size(); i++){
58 |         cout<<v[i]<<" ";
59 |     }
60 |     return 0;
61 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ![Screenshot-1](https://github.com/deathook007/DSA-and-Coding-Practice/blob/master/Data%20Structures%20and%20Algorithms.jpeg)
 2 | 
 3 | # Complexity Analysis 📈
 4 | 
 5 | ![Screenshot-1](https://github.com/deathook007/DSA-and-Coding-Practice/blob/master/Time%20complex.png)
 6 | 
 7 | ### Linear Search
 8 | - Time complexity : O(n)
 9 | - Space complexity : O(1)
10 | 
11 | ### Binary Search
12 | - Time complexity : O(log(n))
13 | - Space complexity : 
14 | -     Itterative version - O(1)
15 | -     Recursive version - O(n)   
16 | 
17 | ###### Binary search works on monotonic functions (non-increasing or non-decreasing)
18 | 
19 | ### Jump Search
20 | - Time complexity : O(√n)
21 | - Space complexity : O(1)
22 | 
23 | ### Interpolation Search
24 | - Time complexity : O(log(log(n))) 
25 | - Space complexity : O(1)
26 | 
27 | ###### Time Complexity increases with the increase in non uniformity of data. For uniformily distributed data Interpolation Search is better than Binary Search while it keeps on changing as uniformity of data changes and go upto O(n), while in case of Binary search its O(log(n)) dispite of how data is distributed in shorted array. Here is the average complexity considering most data to be uniform. 
28 | 
29 | ### Exponential Search
30 | - Time complexity : O(log(n)) 
31 | - Space complexity : 
32 | -     Itterative version - O(1)
33 | -     Recursive version - O(n) 
34 | 
35 | ###### Time Complexity depends on binary search only not exponential searcch(O(1)). The Exponential Search is better than Binary Search in every case specially for UNBOUNDED ARRAYS 
36 | 
37 | ### Fibonacci Search
38 | - Time complexity : O(log(n))
39 | - Space complexity : O(1) 
40 | 
41 | ### Bubble Sort
42 | - Time complexity : O(n²)
43 | - Space complexity : O(1)
44 | 
45 | ### Insertion Sort
46 | - Time complexity : O(n²)
47 | - Space complexity : O(1)
48 | 
49 | ### Selection Sort
50 | - Time complexity : O(n²)
51 | - Space complexity : O(1)
52 | 
53 | ### Inbuilt Sort
54 | - Time complexity : O(n)
55 | - Space complexity : O(1)
56 | 
57 | ### Counting Sort
58 | - Time complexity : O(n + Range) ~ O(n)
59 | - Space complexity : O(Range)
60 | 
61 | 


--------------------------------------------------------------------------------
/Recursion/Repetitive Addition Of Digits.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Repetitive Addition Of DigitsApproach - Using unordered_map for hashing
 3 | Time Complexity : O(1)
 4 | Space Complexity : O(1)
 5 | */
 6 | 
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | int singleDigit(long long number)
10 | {
11 |     int sum = 0;
12 |     while(number)
13 |     {
14 |         sum += (number % 10);
15 |         number /= 10;
16 |     }
17 |     if(sum < 10)
18 |         return sum;
19 |     else
20 |         return singleDigit(sum);
21 | }
22 | 
23 | int main(){
24 |     long long num = 98;
25 |     cout<<singleDigit(num);
26 |     return 0;
27 | }


--------------------------------------------------------------------------------
/Searching/Binary Searching.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Binary Seaching
 3 | Approach - Iterative Version (Divide in Middle)
 4 | Time Complexity : O(logN)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | int binarySearching(int arr[], int size, int target) {
10 | 	int start = 0;
11 |     int end = size - 1;
12 |     while(start <= end){
13 |         int middle = start + (end - start) / 2;
14 |         if(arr[middle] == target){
15 |             return middle + 1;
16 |         }else if(arr[middle] > target){
17 |             end = middle - 1;
18 |         }else if(arr[middle] < target){
19 |             start = middle + 1;
20 |         }
21 |     }
22 |     return -1;
23 | }
24 | 
25 | int main(){
26 |     int arr[] = {1, 2, 3, 4, 5}; //Sorted
27 |     int n = sizeof(arr) / sizeof(arr[0]);
28 |     int target = 4;
29 |     int result = binarySearching(arr, n, target);
30 |     if(result == -1){
31 |         cout<<"Element is not present in array!";
32 |     }else{
33 |         cout<<"Element is present at index "<<result;
34 |     }
35 |     return 0;
36 | }
37 | 
38 | /* 
39 | Binary Seaching
40 | Approach - Recursive Version (Divide in Middle)
41 | Time Complexity : O(log N)
42 | Space Complexity : O(log N)
43 | */
44 | #include<bits/stdc++.h>
45 | using namespace std;
46 | int binarySearching(int arr[], int start, int end, int target){
47 |     if(start <= end){
48 |         int middle = start + (end - start) / 2;
49 |         if(arr[middle] == target){
50 |             return middle + 1;
51 |         }else if(arr[middle] > target){
52 |             return binarySearching(arr, start, middle - 1, target);
53 |         }else if(arr[middle] < target){
54 |             return binarySearching(arr, middle + 1, end, target);
55 |         }
56 |     }
57 |     return -1;
58 | }
59 | 
60 | int main(){
61 |     int arr[] = {1, 2, 3, 4, 5}; //Sorted
62 |     int n = sizeof(arr) / sizeof(arr[0]);
63 |     int target = 4;
64 |     int result = binarySearching(arr, 0, n-1, target);
65 |     if(result == -1){
66 |         cout<<"Element is not present in array!";
67 |     }else{
68 |         cout<<"Element is present at index "<<result;
69 |     }
70 |     return 0;
71 | }


--------------------------------------------------------------------------------
/Searching/Ceil in a Sorted Array.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Floor in a Sorted Array
 3 | Approach - Binary search
 4 | Time Complexity : O(logN)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | 
10 | int findCeil(int arr[], int size, int target){
11 |     int start = 0;
12 |     int end = size - 1;
13 |     while(start <= end){
14 |         int middle = start + (end - start) / 2;
15 |         if(arr[middle] < target){
16 |             start = middle + 1;
17 |         }else if(arr[middle] > target){
18 |             end = middle - 1;
19 |         }else{
20 |             return middle;
21 |         }
22 |     }
23 |     return start;
24 | }
25 | 
26 | 
27 | int main(){
28 |     int arr[] = {1, 2, 8, 10, 11, 12, 19};
29 |     int n = sizeof(arr) / sizeof(arr[0]);
30 |     int X = 0;
31 |     cout<< findCeil(arr, n, X);
32 |     return 0;
33 | }


--------------------------------------------------------------------------------
/Searching/Count 1’s in a sorted binary array.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Count 1’s in a sorted binary array
 3 | Approach - Binary Searching until found the last 1
 4 | Time Complexity < O(logN)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | 
10 | int countOnes(int arr[], int size){
11 |     int start = 0;
12 |     int end = size - 1;
13 |     while(start <= end){
14 |         int middle = start + (end - start) / 2;
15 |         if(arr[middle] < 1){
16 |             end = middle - 1;
17 |         }else if(arr[middle] > 1){
18 |             start = middle + 1;
19 |         }else{
20 |             if(middle == size - 1 || arr[middle + 1] == 0){
21 |                 return middle + 1;
22 |             }else{
23 |                 start = middle + 1;
24 |             }    
25 |         }
26 |     }
27 | }
28 | 
29 | int main(){
30 |     int arr[] = {1, 1, 1, 1, 0 , 0}; //Sorted
31 |     int n = sizeof(arr) / sizeof(arr[0]);
32 |     int result = countOnes(arr, n);
33 |     cout<<result;
34 |     return 0;
35 | }


--------------------------------------------------------------------------------
/Searching/Exponential Searching.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Exponential Seaching
 3 | Approach - Rise Exponentially and Divide in Middle
 4 | Time Complexity < O(logN)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | 
10 | int binarySearching(int arr[], int start, int end, int target){
11 |     while(start <= end){
12 |         int middle = start + (end - start) / 2;
13 |         if(arr[middle] == target){
14 |             return middle + 1;
15 |         }else if(arr[middle] > target){
16 |             end = middle - 1;
17 |         }else if(arr[middle] < target){
18 |             start = middle + 1;
19 |         }
20 |     }
21 |     return -1;
22 | }
23 | 
24 | int exponentialSearching(int arr[], int size, int target) {
25 | 	if(arr[0] == target){
26 |         return 1;
27 |     }
28 |     int i = 1;
29 |     while(i<size && arr[i] <= target){
30 |         i = i * 2;
31 |     }
32 |     return binarySearching(arr, i/2, min(i, size-1), target);
33 | }
34 | 
35 | int main(){
36 |     int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 ,12, 13, 14, 15}; //Sorted
37 |     int n = sizeof(arr) / sizeof(arr[0]);
38 |     int target = 13;
39 |     int result = exponentialSearching(arr, n, target);
40 |     if(result == -1){
41 |         cout<<"Element is not present in array!";
42 |     }else{
43 |         cout<<"Element is present at index "<<result;
44 |     }
45 |     return 0;
46 | }


--------------------------------------------------------------------------------
/Searching/Find K Rotation.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Search in a Rotated Array with Distinct Elements
 3 | Approach - Binary search (Start < End)
 4 | Time Complexity : O(logN)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | 
10 | int findKRotation(int arr[], int size){
11 |     int start = 0;
12 |     int end = size - 1;
13 |     while(star < end){
14 |         int middle = start + (end - start) / 2;
15 |         if(arr[middle] < arr[size - 1]){
16 |             end = middle;
17 |         }else if(arr[middle] >= arr[size - 1]){
18 |             start = middle + 1;
19 |         }
20 |     }
21 |     if(arr[start] < arr[0]){
22 |         return start;
23 |     }
24 |     return 0;
25 | }
26 | 
27 | 
28 | int main(){
29 |     int arr[] = {4, 5, 1, 2, 3};
30 |     int n = sizeof(arr) / sizeof(arr[0]);
31 |     int result = findKRotation(arr, n);
32 |     cout<<"The array is rotated "<<result<<" times.";
33 |     return 0;
34 | }


--------------------------------------------------------------------------------
/Searching/Find Minimum in Rotated Sorted Array with Distinct Elements.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Find Minimum in Rotated Sorted Array with Distinct Elements
 3 | Approach - Binary Searching for Pivot Element
 4 | Time Complexity : O(logN)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | 
10 | int findMinElement(int arr[], int size){
11 |     int start = 0;
12 |     int end = size - 1;
13 |     while(star < end){
14 |         int middle = start + (end - start) / 2;
15 |         if(arr[middle] < arr[end]){
16 |             end = middle;
17 |         }else if(arr[middle] >= arr[end]){
18 |             start = middle + 1;
19 |         }
20 |     }
21 |     if(arr[start] < arr[0]){
22 |         return arr[start];
23 |     }
24 |     return arr[0];
25 | }
26 | 
27 | 
28 | int main(){
29 |     int arr[] = {4, 5, 1, 2, 3};
30 |     int n = sizeof(arr) / sizeof(arr[0]);
31 |     int result = findMinElement(arr, n);
32 |     cout<<"The array is rotated "<<result<<" times.";
33 |     return 0;
34 | }


--------------------------------------------------------------------------------
/Searching/Find Minimum in Rotated Sorted Array with Duplicates.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Find Minimum in Rotated Sorted Array with Duplicates
 3 | Approach - Binary Searching for Pivot Element
 4 | Time Complexity : O(logN)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | 
10 | int findMinElement(int arr[], int size){
11 |     int start = 0;
12 |     int end = size - 1;
13 |     while(star < end){
14 |         int middle = start + (end - start) / 2;
15 |         if(arr[middle] < arr[end]){
16 |             end = middle;
17 |         }else if(arr[middle] > arr[end]){
18 |             start = middle + 1;
19 |         }else{
20 |             end--;
21 |         }
22 |     }
23 |     if(arr[start] < arr[0]){
24 |         return arr[start];
25 |     }
26 |     return arr[0];
27 | }
28 | 
29 | 
30 | int main(){
31 |     int arr[] = {4, 5, 5, 1, 1, 2, 2, 3};
32 |     int n = sizeof(arr) / sizeof(arr[0]);
33 |     int result = findMinElement(arr, n);
34 |     cout<<"The array is rotated "<<result<<" times.";
35 |     return 0;
36 | }


--------------------------------------------------------------------------------
/Searching/Find Smallest Letter Greater Than Target.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Find Smallest Letter Greater Than Target
 3 | Approach - Binary search (Non-Decreasing Sorted)
 4 | Time Complexity : O(logN)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | 
10 | char nextGreatestLetter(char arr[], int size, char target){
11 |     int start = 0;
12 |     int end = size - 1;
13 |     if(target > arr[end]){
14 |         return arr[start];
15 |     }
16 |     while(start <= end){
17 |         int middle = start + (end - start) / 2;
18 |         if(arr[middle] == target){
19 |             start = middle + 1;
20 |         }else if(arr[middle] < target){
21 |             start = middle + 1;
22 |         }else{
23 |             end = middle - 1;
24 |         }
25 |     }
26 |     if(start == size){
27 |         start = 0;
28 |     }
29 |     return arr[start];
30 | }
31 | 
32 | 
33 | int main(){
34 |     char arr[] = {'c', 'f' ,'j'};
35 |     char c = 'a';
36 |     int n = sizeof(arr) / sizeof(arr[0]);
37 |     cout<<"Smallest character larger than target is : "<<nextGreatestLetter(arr, n, c);
38 |     return 0;
39 | }


--------------------------------------------------------------------------------
/Searching/Find in Mountain Array.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Find in Mountain Array
 3 | Approach - Find Peak and Binary Search in two Halfs
 4 | Time Complexity : O(log N)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | int findInMountainArray(int arr[], int size, int target){
10 |     int start = 0;
11 |     int end = size - 1;
12 |     while(start <= end){
13 |         int mid = start + (end - start) / 2;
14 |         if(arr[mid] < arr[mid + 1]){
15 |             start = mid + 1;
16 |         }else{
17 |             end = mid - 1;
18 |         }
19 |     }
20 |     int peak = start;
21 |     start = 0; end = peak;
22 |     while(start <= end){
23 |         int mid = start + (end - start) / 2;
24 |         if(arr[mid] == target){
25 |             return mid;
26 |         }else if(arr[mid] < target){
27 |             start = mid + 1;
28 |         }else{
29 |             end = mid - 1;
30 |         }
31 |     }
32 |     start = peak + 1, end = size - 1;
33 |     while(start <= end){
34 |         int mid = start + (end - start) / 2;
35 |         if(arr[mid] == target){
36 |             return mid;
37 |         }else if(arr[mid] > target){
38 |             start = mid + 1;
39 |         }else{
40 |             end = mid - 1;
41 |         }
42 |     }
43 |     return -1;
44 | }
45 | 
46 | int main(){
47 |     int arr[] = {1, 2, 3, 4, 5, 3, 1}; //Sorted
48 |     int n = sizeof(arr) / sizeof(arr[0]);
49 |     int target = 3;
50 |     cout<<"Target found at array Index : "<<findInMountainArray(arr, n, target);
51 | 
52 |     return 0;
53 | }


--------------------------------------------------------------------------------
/Searching/Find position of an element in a sorted array of infinite numbers.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Find position of an element in a sorted array of infinite numbers
 3 | Approach - Jump and Search in a particular Window
 4 | Time Complexity : O(logN)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | int binarySearching(int arr[], int start, int end, int target) {
10 |     while(start <= end){
11 |         int middle = start + (end - start) / 2;
12 |         if(arr[middle] == target){
13 |             return middle;
14 |         }else if(arr[middle] > target){
15 |             end = middle - 1;
16 |         }else if(arr[middle] < target){
17 |             start = middle + 1;
18 |         }
19 |     }
20 |     return -1;
21 | }
22 | 
23 | int findPos(int arr[], int target){
24 |     int low = 0;
25 |     int high = 1;
26 |     int value = arr[0];
27 |     while(value < target){
28 |         low = high;
29 |         high = 2 * high;
30 |         value = arr[high];
31 |     }
32 |     return binarySearching(arr, low, high, target);
33 | }
34 | 
35 | 
36 | int main(){
37 |     int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}; //Sorted and N cannot be taken
38 |     int target = 16;
39 |     int result = findPos(arr, target);
40 |     if(result == -1){
41 |         cout<<"Element is not present in array!";
42 |     }else{
43 |         cout<<"Element is present at index "<<result;
44 |     }
45 |     return 0;
46 | }


--------------------------------------------------------------------------------
/Searching/First and last occurrences of X Modularly.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | First and last occurrences of X
 3 | Approach - Binary search (Left half + Right half)
 4 | Time Complexity : O(logN)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | 
10 | search(int arr[], int size, int target, bool findStartIndex){
11 |     int start = 0;
12 |     int end = size - 1;
13 |     int temp = -1;
14 |     int middle;
15 |     while(start <= end){
16 |         middle = start + (end - start) / 2;
17 |         if(arr[middle] < target){
18 |             start = middle + 1;
19 |         }else if(arr[middle] > target){
20 |             end = middle - 1;
21 |         }else{
22 |             temp = middle;
23 |             if(findStartIndex){
24 |                 end = middle - 1;
25 |             }else{
26 |                 start = middle + 1;
27 |             }
28 |         }
29 |     }
30 |     return temp;
31 | }
32 | 
33 | vector<int> firstAndLast(int arr[], int size, int target){
34 |     vector<int> v(2, -1);
35 |     v[0] = search(arr, size, target, true);
36 |     v[1] = search(arr, size, target, false);
37 |     return v;
38 | }
39 | 
40 | 
41 | int main(){
42 |     int arr[] = {1, 2, 3, 4, 4, 4, 7, 8, 9};
43 |     int n = sizeof(arr) / sizeof(arr[0]);
44 |     int X = 4;
45 |     vector<int> v = firstAndLast(arr, n, X);
46 |     cout<<"First occurrence is at Index: "<<v[0]<<" "<<"Last occurrence is at Index: "<<v[1];
47 |     return 0;
48 | }


--------------------------------------------------------------------------------
/Searching/First and last occurrences of X.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | First and last occurrences of X
 3 | Approach - Binary search (Left half + Right half)
 4 | Time Complexity : O(logN)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | 
10 | vector<int> firstAndLast(int arr[], int size, int target){
11 |     vector<int> v;
12 |     int start = 0;
13 |     int end = size - 1;
14 |     int temp = -1;
15 |     int middle;
16 |     while(start <= end){
17 |         middle = start + (end - start) / 2;
18 |         if(arr[middle] == target){
19 |             temp = middle;
20 |             end = middle - 1;
21 |         }else if(arr[middle] < target){
22 |             start = middle + 1;
23 |         }else if(arr[middle] > target){
24 |             end = middle - 1;
25 |         }
26 |     }
27 |     if(temp == -1){
28 |         v.push_back(-1);
29 |         return v;
30 |     }
31 |     v.push_back(temp);
32 |     start = 0;
33 |     end = size - 1;
34 |     temp = -1;
35 |     while(start <= end){
36 |         middle = start + (end - start) / 2;
37 |         if(arr[middle] == target){
38 |             temp = middle;
39 |             start = middle + 1;
40 |         }else if(arr[middle] < target){
41 |             start = middle + 1;
42 |         }else if(arr[middle] > target){
43 |             end = middle - 1;
44 |         }
45 |     }
46 |     v.push_back(temp);
47 |     return v;
48 | }
49 | 
50 | 
51 | int main(){
52 |     int arr[] = {1, 2, 3, 4, 4, 4, 7, 8, 9};
53 |     int n = sizeof(arr) / sizeof(arr[0]);
54 |     int X = 4;
55 |     vector<int> v = firstAndLast(arr, n, X);
56 |     cout<<"First occurrence is at Index: "<<v[0]<<" "<<"Last occurrence is at Index: "<<v[1];
57 |     return 0;
58 | }


--------------------------------------------------------------------------------
/Searching/Floor in a Sorted Array.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Floor in a Sorted Array
 3 | Approach - Binary search
 4 | Time Complexity : O(logN)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | 
10 | int findFloor(int arr[], int size, int target){
11 |     int start = 0;
12 |     int end = size - 1;
13 |     while(start <= end){
14 |         int middle = start + (end - start) / 2;
15 |         if(arr[middle] < target){
16 |             start = middle + 1;
17 |         }else if(arr[middle] > target){
18 |             end = middle - 1;
19 |         }else{
20 |             return middle;
21 |         }
22 |     }
23 |     return end;
24 | }
25 | 
26 | 
27 | int main(){
28 |     int arr[] = {1, 2, 8, 10, 11, 12, 19};
29 |     int n = sizeof(arr) / sizeof(arr[0]);
30 |     int X = 0;
31 |     cout<< findFloor(arr, n, X);
32 |     return 0;
33 | }


--------------------------------------------------------------------------------
/Searching/Interpolation Searching.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Interpolation Searching
 3 | Approach - Mathematical Approach (For uniformly distributed data only!)
 4 | Time Complexity : O(log(log N))
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | int interpolationSearching(int arr[], int size, int target){
10 | 	int low = 0;
11 |     int high = size - 1;
12 |     while(low <= high && arr[low] <= target && arr[high] >= target){
13 |     if(low == high){
14 |         if(arr[low] == target){
15 |             return low + 1;
16 |         }
17 |         return -1;
18 |     }
19 |     int pos = low + (((target - arr[low])/(arr[high] - arr[low])) * (high - low));
20 |     if(arr[pos] == target){
21 |         return pos+1;
22 |     }
23 |     if(arr[pos] > target){
24 |         high = pos - 1;
25 |     }
26 |     if(arr[pos] < target){
27 |         low = pos + 1;
28 |     }
29 |     return -1;
30 | }
31 | 
32 | int main(){
33 |     int arr[] = {1, 2, 3, 4, 5}; //Sorted
34 |     int n = sizeof(arr) / sizeof(arr[0]);
35 |     int target = 4;
36 |     int result = interpolationSearching(arr, n, target);
37 |     if(result == -1){
38 |         cout<<"Element is not present in array!";
39 |     }else{
40 |         cout<<"Element is present at index "<<result;
41 |     }
42 |     return 0;
43 | }


--------------------------------------------------------------------------------
/Searching/Jump Searching.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Jump Seaching
 3 | Approach - Sliding window Approach
 4 | Time Complexity : O(√N)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | int jumpSearching(int arr[], int size, int target){
10 | 	int start = 0;
11 |     int end = sqrt(size);
12 |     while(arr[end] < target && end < size){
13 |         start = end;
14 |         end += sqrt(size);
15 | 
16 |         if(end > size - 1){
17 |             end = size;
18 |             }
19 |     }
20 |     for(int i = start; i<=end; i++){
21 |         if(arr[i] == target){
22 |             return i + 1;
23 |         }
24 |     }
25 |     return -1;
26 | }
27 | 
28 | int main(){
29 |     int arr[] = {1, 2, 3, 4, 5}; //Sorted
30 |     int n = sizeof(arr) / sizeof(arr[0]);
31 |     int target = 4;
32 |     int result = jumpSearching(arr, n, target);
33 |     if(result == -1){
34 |         cout<<"Element is not present in array!";
35 |     }else{
36 |         cout<<"Element is present at index "<<result;
37 |     }
38 |     return 0;
39 | }


--------------------------------------------------------------------------------
/Searching/Linear Searching.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Linear Seaching
 3 | Approach - Iterative Version
 4 | Time Complexity : O(N)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | int linearSearching(int arr[], int size, int target) {
10 | 	for(int i=0; i<size; i++){
11 |         if(arr[i] == target){
12 |             return i + 1;
13 |         }
14 |     }
15 |     return -1;
16 | }
17 | 
18 | int main(){
19 |     int arr[] = {1, 2, 4, 3, 5};
20 |     int n = sizeof(arr) / sizeof(arr[0]);
21 |     int target = 4;
22 |     int result = linearSearching(arr, n, target);
23 |     if(result == -1){
24 |         cout<<"Element is not present in array!";
25 |     }else{
26 |         cout<<"Element is present at index "<<result;
27 |     }
28 |     return 0;
29 | }
30 | 
31 | /* 
32 | Linear Seaching
33 | Approach - Iterative Version
34 | Time Complexity : O(N)
35 | Space Complexity : O(N)
36 | */
37 | #include<bits/stdc++.h>
38 | using namespace std;
39 | int linearSearching(int arr[], int size, int target){
40 | 	if(size == 0){
41 |         return -1;
42 |     }else{
43 |         if(arr[size - 1] == target){
44 |             return size;
45 |         }else{
46 |             linearSearching(arr, size - 1, target);
47 |         }
48 |     }
49 | }
50 | 
51 | int main(){
52 |     int arr[] = {1, 2, 4, 3, 5};
53 |     int n = sizeof(arr) / sizeof(arr[0]);
54 |     int target = 4;
55 |     int result = linearSearching(arr, n, target);
56 |     if(result == -1){
57 |         cout<<"Element is not present in array!";
58 |     }else{
59 |         cout<<"Element is present at index "<<result;
60 |     }
61 |     return 0;
62 | }


--------------------------------------------------------------------------------
/Searching/Peak element.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Peak element
 3 | Approach - Binary search
 4 | Time Complexity : O(logN)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | 
10 | int PeakElement(int arr[], int size){
11 |     /* When only single element is present */
12 |     if(size == 1){
13 |         return 0;
14 |     }
15 |     /* When only increasing element is present */
16 |     if(arr[0] > arr[1]){
17 |         return 0;
18 |     }
19 |     /* When only decreasing element is present */
20 |     if(arr[size - 1] > arr[size - 2]){
21 |         return size - 1;
22 |     }
23 |     int low = 0;
24 |         int high = size - 1;
25 |         while(low <= high){
26 |         int mid = low + (high - low) / 2;
27 |         if(arr[mid] < arr[mid + 1]){
28 |             low = mid + 1;
29 |         }else{
30 |             high = mid - 1;
31 |         }
32 |     }
33 |     return low;
34 | }
35 | 
36 | 
37 | int main(){
38 |     int arr[] = {1, 2, 8, 10, 6, 3, 0};
39 |     int n = sizeof(arr) / sizeof(arr[0]);
40 |     cout<<"Peak of mountain is at Index : "<<PeakElement(arr, n);
41 |     return 0;
42 | }


--------------------------------------------------------------------------------
/Searching/Search in Rotated Sorted Array with Duplicates.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Search in a Rotated Array with Distinct Elements
 3 | Approach - Binary search (Non-Decreasing Sorted) and Leave Duplicates from End
 4 | Time Complexity : O(logN)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | 
10 | bool searchRotatedArray(int arr[], int size, int target){
11 |     int start = 0;
12 |     int end = size - 1;
13 |     while(start <= end){
14 |         int middle = start + (end - start) / 2;
15 |         if(arr[middle] == target){
16 |             return true;
17 |         }
18 |         if(arr[middle] < arr[end]){
19 |             if(target > arr[middle] && target <= arr[end]){
20 |                 start = middle + 1;
21 |             }else{
22 |                 end = middle - 1;
23 |             }
24 |         }else if(arr[middle] > arr[end]){
25 |             if(target < arr[middle] && target >= arr[start]){
26 |                 end = middle - 1;
27 |             }else{
28 |                 start = middle + 1;
29 |             }
30 |         }else{
31 |             end--;
32 |         }
33 |     }
34 |     return false;
35 | }
36 | 
37 | 
38 | int main(){
39 |     int arr[] = {5, 6, 7, 8, 8, 9, 10, 1, 1, 2, 3, 4};
40 |     int target = 8;
41 |     int n = sizeof(arr) / sizeof(arr[0]);
42 |     bool result = searchRotatedArray(arr, n, target);
43 |     if(!result){
44 |         cout<<"Element is not present in array :(";
45 |     }else{
46 |         cout<<"Element is present in array :)";
47 |     }
48 |     return 0;
49 | }


--------------------------------------------------------------------------------
/Searching/Search in a Rotated Array with Distinct Elements.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Search in a Rotated Array with Distinct Elements
 3 | Approach - Binary search (Non-Decreasing Sorted)
 4 | Time Complexity : O(logN)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | 
10 | int searchRotatedArray(int arr[], int size, int target){
11 |     int start = 0;
12 |     int end = size - 1;
13 |     while(start <= end){
14 |         int middle = start + (end - start) / 2;
15 |         if(arr[middle] == target){
16 |             return middle;
17 |         }
18 |         if(arr[middle] < arr[end]){
19 |             if(target > arr[middle] && target <= arr[end]){
20 |                 start = middle + 1;
21 |             }else{
22 |                 end = middle - 1;
23 |             }
24 |         }else{
25 |             if(target < arr[middle] && target >= arr[start]){
26 |                 end = middle - 1;
27 |             }else{
28 |                 start = middle + 1;
29 |             }
30 |         }
31 |     }
32 |     return -1;
33 | }
34 | 
35 | 
36 | int main(){
37 |     int arr[] = {5, 6, 7, 8, 9, 10, 1, 2, 3};
38 |     int target = 10;
39 |     int n = sizeof(arr) / sizeof(arr[0]);
40 |     int result = searchRotatedArray(arr, n, target);
41 |     if(result == -1){
42 |         cout<<"Element is not present in array!";
43 |     }else{
44 |         cout<<"Element is present at index : "<<result;
45 |     }
46 |     return 0;
47 | }


--------------------------------------------------------------------------------
/Sorting/Bubble Sorting Optimisefd for O(N) Sorted Elements.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Bubble Sorting
 3 | Time Complexity : O(N^2) 
 4 | Best Complexity : O(N)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | 
10 | void bubbleSorting(int arr[], int size){
11 |     for(int i=0; i<size - 1; i++){
12 |         bool temp = false;
13 |         for(int j=0; j<size - i - 1; j++){
14 |             if(arr[j] > arr[j + 1]){
15 |                 swap(arr[j], arr[j + 1]);
16 |                 temp = true;
17 |             }
18 |         }
19 |         if(temp == false){
20 |             break;
21 |         }
22 |     }
23 |     
24 |     for(int i=0; i<size; i++){
25 |         cout<<arr[i]<<" ";
26 |     }
27 | }
28 | 
29 | int main(){
30 |     int arr[] = {1, 4, 6, 8, 3, 5, 9, 2, 7};
31 |     int n = sizeof(arr) / sizeof(arr[0]);
32 |     bubbleSorting(arr, n);
33 |     return 0;
34 | }


--------------------------------------------------------------------------------
/Sorting/Bubble Sorting.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Bubble Sorting
 3 | Time Complexity : O(N^2)
 4 | Space Complexity : O(1)
 5 | */
 6 | #include<bits/stdc++.h>
 7 | using namespace std;
 8 | 
 9 | void bubbleSorting(int arr[], int size){
10 |     for(int i=0; i<size - 1; i++){
11 |         for(int j=0; j<size - i - 1; j++){
12 |             if(arr[j] > arr[j + 1]){
13 |                 int temp = arr[j];
14 |                 arr[j] = arr[j + 1];
15 |                 arr[j + 1] = temp;
16 |             }
17 |         }
18 |     }
19 |     
20 |     for(int i=0; i<size; i++){
21 |         cout<<arr[i]<<" ";
22 |     }
23 | }
24 | 
25 | int main(){
26 |     int arr[] = {1, 4, 6, 8, 3, 5, 9, 2, 7};
27 |     int n = sizeof(arr) / sizeof(arr[0]);
28 |     bubbleSorting(arr, n);
29 |     return 0;
30 | }


--------------------------------------------------------------------------------
/Sorting/Count Sorting.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Bubble Sorting
 3 | Time Complexity : O(Range + N)
 4 | Space Complexity : O(Range)
 5 | */
 6 | #include<bits/stdc++.h>
 7 | using namespace std;
 8 | 
 9 | void countSorting(int arr[], int size){
10 |     int largest = INT_MIN;
11 |     for(int i=0; i<size; i++){
12 |         largest = max(largest, arr[i]);
13 |     }
14 |     vector<int> v(largest + 1, 0);
15 |     for(int i=0; i<size; i++){
16 |         v[arr[i]]++;
17 |     }
18 |     int j = 0;
19 |     for(int i=0; i<v.size(); i++){
20 |         while(v[i]--){
21 |             arr[j] = i;
22 |             j++;
23 |         }
24 |     }
25 |     for(int i=0; i<size; i++){
26 |         cout<<arr[i]<<" ";
27 |     }
28 | }
29 | 
30 | int main(){
31 |     int arr[] = {1, 4, 6, 8, 3, 5, 9, 2, 7};
32 |     int n = sizeof(arr) / sizeof(arr[0]);
33 |     countSorting(arr, n);
34 |     return 0;
35 | }


--------------------------------------------------------------------------------
/Sorting/Defense of a Kingdom.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | - Defense of a Kingdom: https://www.spoj.com/problems/DEFKIN/
 3 | * On each level a player defends the Kingdom that is represented by a rectangular grid of cells. 
 4 | * The player builds crossbow towers in some cells of the grid. 
 5 | * The tower defends all the cells in the same row and the same column. 
 6 | * No two towers share a row or a column. 
 7 | * The penalty of the position is the number of cells in the largest undefended rectangle.
 8 | * Calculates the penalty of the given position.
 9 | 
10 | - Input:
11 | * The first line of the input file contains the number of test cases.
12 | * Each test case consists of a line with three integer numbers: w — width of the grid, h — height of the grid and n — number of crossbow towers (1 ≤ w, h ≤ 40 000; 0 ≤ n ≤ min(w, h)).
13 | * Each of the following n lines contains two integer numbers xi and yi — the coordinates of the cell occupied by a tower (1 ≤ xi ≤ w; 1 ≤ yi ≤ h).
14 | 
15 | - Output:
16 | * For each test case, output a single integer number — the number of cells in the largest rectangle that is not defended by the towers.
17 | 
18 | - Input:
19 | 1
20 | 15 8 3
21 | 3 8
22 | 11 2
23 | 8 6
24 | 
25 | - Output:
26 | 12 
27 | */
28 | #include<bits/stdc++.h>
29 | using namespace std;
30 | 
31 | int main(){
32 |     int t;
33 |     cin>>t;
34 |     while(t--){
35 |         int w, h, n;
36 |         cin>>w>>h>>n;
37 |         vector<int> xCord, yCord;
38 |         // 1 Extra tower in origin.
39 |         xCord.push_back(0); // xCord = [0] 
40 |         yCord.push_back(0); // yCord = [0]
41 |         while(n--){
42 |             int x, y;
43 |             cin>>x>>y;
44 |             xCord.push_back(x); // xCord = [0, 3, 11, 8]
45 |             yCord.push_back(y); // yCord = [0, 8, 2, 6]
46 |         }
47 |         // 1 Extra tower at end.
48 |         xCord.push_back(w + 1); // xCord = [0, 3, 11, 8, 16]
49 |         yCord.push_back(h + 1); // yCord = [0, 8, 2, 6, 9]
50 | 
51 |         sort(xCord.begin(), xCord.end()); // xCord = [0, 3, 8, 11, 16]
52 |         sort(yCord.begin(), yCord.end()); // yCord = [0, 2, 6, 8, 9]
53 | 
54 |         int maxXCord = 0, maxYCord = 0;
55 | 
56 |         for(int i=0; i<xCord.size() - 1; i++){
57 |             // Subtract 1 fro the tower occupied cord.
58 |             maxXCord = max(maxXCord, xCord[i + 1] - xCord[i] - 1);
59 |             maxYCord = max(maxYCord, yCord[i + 1] - yCord[i] - 1);
60 |         }
61 |         cout<<maxXCord * maxYCord;
62 |     }
63 |     return 0;
64 | }


--------------------------------------------------------------------------------
/Sorting/Insertion Sorting.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Bubble Sorting
 3 | Time Complexity : O(N^2)
 4 | Space Complexity : O(1)
 5 | */
 6 | #include<bits/stdc++.h>
 7 | using namespace std;
 8 | 
 9 | void bubbleSorting(int arr[], int size){
10 |     for(int i=1; i<size; i++){
11 |         int temp = arr[i];
12 |         int previous = i - 1;
13 |         while(previous >= 0 && arr[previous] > temp){
14 |             arr[previous + 1] = arr[previous];
15 |             previous--;
16 |         }
17 |         arr[previous + 1] = temp;
18 |     }
19 |     
20 |     for(int i=0; i<size; i++){
21 |         cout<<arr[i]<<" ";
22 |     }
23 | }
24 | 
25 | int main(){
26 |     int arr[] = {1, 4, 6, 8, 3, 5, 9, 2, 7};
27 |     int n = sizeof(arr) / sizeof(arr[0]);
28 |     bubbleSorting(arr, n);
29 |     return 0;
30 | }


--------------------------------------------------------------------------------
/Sorting/Selection Sorting.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Bubble Sorting
 3 | Time Complexity : O(N^2)
 4 | Space Complexity : O(1)
 5 | */
 6 | #include<bits/stdc++.h>
 7 | using namespace std;
 8 | 
 9 | void selectionSort(int arr[], int size){
10 |     for(int i=0; i<size - 1; i++){
11 |         int current = arr[i];
12 |         int min_pos = i;
13 |         for(int j=i; j<size; j++){
14 |             if(arr[j] < arr[min_pos]){
15 |                 min_pos = j;
16 |             }
17 |         }
18 |         swap(arr[min_pos], arr[i]);
19 |     }
20 |     
21 |     for(int i=0; i<size; i++){
22 |         cout<<arr[i]<<" ";
23 |     }
24 | }
25 | 
26 | int main(){
27 |     int arr[] = {1, 4, 6, 8, 3, 5, 9, 2, 7};
28 |     int n = sizeof(arr) / sizeof(arr[0]);
29 |     selectionSort(arr, n);
30 |     return 0;
31 | }


--------------------------------------------------------------------------------
/Sorting/Sorting with Comparators.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Sorting with Comparators
 3 | Time Complexity : O(NlogN)
 4 | Space Complexity : O(1)
 5 | */
 6 | #include<bits/stdc++.h>
 7 | using namespace std;
 8 | 
 9 | bool cmp(int a, int b){
10 |     return a > b;
11 | }
12 | 
13 | int main(){
14 |     int arr[] = {1, 4, 6, 8, 3, 5, 9, 2, 7};
15 |     int n = sizeof(arr) / sizeof(arr[0]);
16 |     
17 |     sort(arr, arr + n);
18 |     cout<<"Elements shorted in ascending order : ";
19 |     for(int i= 0; i<n; i++){
20 |         cout<<arr[i]<<" ";
21 |     }
22 | 
23 |     cout<<endl;
24 | 
25 |     sort(arr, arr + n, cmp); // OR sort(arr, arr + n, greater<int>());
26 |     cout<<"Elements shorted in descending order : ";
27 |     for(int i=0; i<n; i++){
28 |         cout<<arr[i]<<" ";
29 |     }
30 | 
31 | 
32 |     return 0;
33 | }


--------------------------------------------------------------------------------
/String/Complement.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Complement (https://practice.geeksforgeeks.org/problems/complement3911/1/#)
 3 | Approach - Using Kadane's Algorithm
 4 | Time Complexity : O(N)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | vector<int> complement(string s, int size){
10 |     int l=0;
11 |     int ans_l,ans_r;
12 |     int maxDiff=0;
13 |     int zeroCount = 0, oneCount = 0;
14 |     for(int i=0; i<n; i++){
15 |         if(str[i] == '0'){
16 |             zeroCount++;
17 |         }
18 |         else oneCount++;
19 |         if(zeroCount < oneCount){
20 |             l=i+1;
21 |             zeroCount = 0;
22 |             oneCount = 0;
23 |         }else{
24 |             if(zeroCount - oneCount > maxDiff){
25 |                 ans_l = l;
26 |                 ans_r = i;
27 |                 maxDiff = zeroCount - oneCount;
28 |             }
29 |         }
30 |     }
31 |     if(maxDiff == 0) return {-1};
32 |     return {ans_l + 1, ans_r + 1};
33 | }
34 | 
35 | int main(){
36 |     string s = "0110010";
37 |     int n = sizeof(arr) / sizeof(arr[0]);
38 |     auto ans = complement(s, n);
39 |     if(ans.size() == 1){
40 |         cout<<ans[0]<<endl;
41 |     }else{
42 |         cout<<ans[0]<<" "<<ans[1]<<endl;
43 |     }
44 |     return 0;
45 | }


--------------------------------------------------------------------------------
/String/Count Occurences of Anagrams.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Count Occurences of Anagrams
 3 | Approach - Using Sliding Window and Hashing
 4 | Time Complexity : O(N * 26) = O(N)
 5 | Space Complexity : O(26) = O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | int countAnagrams(string s, string p){
10 |     vector<int> sHash(26, 0), pHash(26, 0);
11 | 	int count = 0;
12 |     int s_len = s.size();
13 |     int p_len = p.size();
14 |         
15 |     for(int i=0; i<p_len; i++){
16 |         pHash[p[i] - 'a']++;
17 |         sHash[s[i] - 'a']++;
18 |     }
19 |         
20 |     if(pHash == sHash){
21 |         count++;
22 |     }
23 |         
24 |     for(int i=p_len; i<s_len; i++){
25 |         sHash[s[i - p_len] - 'a']--;
26 |         sHash[s[i] - 'a']++;
27 |         if(sHash == pHash){
28 |             count++;
29 |         }
30 |     }
31 |     return count;
32 | }
33 | 
34 | int main(){
35 |     string s = "cbaebabacd";
36 |     string p = "abc";
37 |     cout<<countAnagrams(s, p);
38 |     return 0;
39 | }


--------------------------------------------------------------------------------
/String/Palindrome String.cpp:
--------------------------------------------------------------------------------
 1 | /* 
 2 | Palindrome String
 3 | Approach - Reverse
 4 | Time Complexity : O(N)
 5 | Space Complexity : O(1)
 6 | */
 7 | #include<bits/stdc++.h>
 8 | using namespace std;
 9 | int isPalindrom(string S){
10 |     string s(S);
11 | 	    reverse(s.begin(), s.end());
12 | 	    if(s == S){
13 | 	        return 1;
14 | 	    }
15 | 	    return 0;
16 | }
17 | 
18 | int main(){
19 |     string s = "abba";
20 |     int result = isPalindrom(s);
21 |     if(result){
22 |         cout<<"Palindrome"<<endl;
23 |     }else{
24 |         cout<<"Not Palindrome;
25 |     }
26 |     return 0;
27 | }


--------------------------------------------------------------------------------
/String/Using get and getline.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int main(){
 5 | 
 6 |     char sentence[10000];
 7 |     char temp = cin.get();
 8 |     int length = 1;
 9 |     while(temp != '\n'){
10 |         sentence[length] = temp;
11 |         temp = cin.get();
12 |     }
13 |     sentence[length] = '\0';
14 |     cout<<sentence<<" Is having length : "<<length<<endl;
15 | 
16 |     // Getline Function
17 |     cin.getline(sentence, 10000);
18 |     cout<<sentence;
19 |     return 0;
20 | }


--------------------------------------------------------------------------------
/Time complex.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/deathook007/Data-Structures-and-Algorithms/2708de795ee2749c4ba479a99e1996a8a2a86271/Time complex.png


--------------------------------------------------------------------------------