Count number of occurrences (or frequency) in a sorted array - GeeksforGeeks

02 Dec, 2021
Given a sorted array arr[] and a number x, write a function that counts the occurrences of x in arr[]. Expected time complexity is O(Logn) 
Examples: 
  Input: arr[] = {1, 1, 2, 2, 2, 2, 3,},   x = 2
  Output: 4 // x (or 2) occurs 4 times in arr[]

  Input: arr[] = {1, 1, 2, 2, 2, 2, 3,},   x = 3
  Output: 1 

  Input: arr[] = {1, 1, 2, 2, 2, 2, 3,},   x = 1
  Output: 2 

  Input: arr[] = {1, 1, 2, 2, 2, 2, 3,},   x = 4
  Output: -1 // 4 doesn't occur in arr[] 
Method 1 (Linear Search) Linearly search for x, count the occurrences of x and return the count. 
C++
Java
Python3
C#
PHP
Javascript
// C++ program to count occurrences of an element#include<bits/stdc++.h>using namespace std; // Returns number of times x occurs in arr[0..n-1]int countOccurrences(int arr[], int n, int x){    int res = 0;    for (int i=0; i<n; i++)        if (x == arr[i])          res++;    return res;} // Driver codeint main(){    int arr[] = {1, 2, 2, 2, 2, 3, 4, 7 ,8 ,8 };    int n = sizeof(arr)/sizeof(arr[0]);    int x = 2;    cout << countOccurrences(arr, n, x);    return 0;}
// Java program to count occurrences// of an element class Main{    // Returns number of times x occurs in arr[0..n-1]    static int countOccurrences(int arr[], int n, int x)    {        int res = 0;        for (int i=0; i<n; i++)            if (x == arr[i])              res++;        return res;    }         public static void main(String args[])    {        int arr[] = {1, 2, 2, 2, 2, 3, 4, 7 ,8 ,8 };        int n = arr.length;        int x = 2;        System.out.println(countOccurrences(arr, n, x));    }}
# Python3 program to count# occurrences of an element # Returns number of times x# occurs in arr[0..n-1]def countOccurrences(arr, n, x):    res = 0    for i in range(n):        if x == arr[i]:            res += 1    return res  # Driver codearr = [1, 2, 2, 2, 2, 3, 4, 7 ,8 ,8]n = len(arr)x = 2print (countOccurrences(arr, n, x))
// C# program to count occurrences// of an elementusing System; class GFG{    // Returns number of times x    // occurs in arr[0..n-1]    static int countOccurrences(int []arr,                                int n, int x)    {        int res = 0;                 for (int i = 0; i < n; i++)            if (x == arr[i])            res++;                     return res;    }         // driver code       public static void Main()    {        int []arr = {1, 2, 2, 2, 2, 3, 4, 7 ,8 ,8 };        int n = arr.Length;        int x = 2;                 Console.Write(countOccurrences(arr, n, x));    }} // This code is contributed by Sam007
<?php// PHP program to count occurrences// of an element // Returns number of times x// occurs in arr[0..n-1]function countOccurrences($arr, $n, $x){    $res = 0;    for ($i = 0; $i < $n; $i++)        if ($x == $arr[$i])        $res++;    return $res;}     // Driver code    $arr = array(1, 2, 2, 2, 2, 3, 4, 7 ,8 ,8 );    $n = count($arr);    $x = 2;    echo countOccurrences($arr,$n, $x);     // This code is contributed by Sam007?>
<script> // Javascript program to count occurrences// of an element      // Returns number of times x occurs in arr[0..n-1]    function countOccurrences(arr,n,x)    {        let res = 0;        for (let i=0; i<n; i++)        {            if (x == arr[i])                res++;        }        return res;    }         arr=[1, 2, 2, 2, 2, 3, 4, 7 ,8 ,8]    let  n = arr.length;    let x = 2;    document.write(countOccurrences(arr, n, x));         // This code is contributed by avanitrachhadiya2155     </script>
Output : 
4
Time Complexity: O(n) Method 2 (Better using Binary Search) We first find an occurrence using binary search. Then we match toward left and right sides of the matched the found index.
C++
Java
Python 3
C#
PHP
Javascript
// C++ program to count occurrences of an element#include <bits/stdc++.h>using namespace std; // A recursive binary search function. It returns// location of x in given array arr[l..r] is present,// otherwise -1int binarySearch(int arr[], int l, int r, int x){    if (r < l)        return -1;     int mid = l + (r - l) / 2;     // If the element is present at the middle    // itself    if (arr[mid] == x)        return mid;     // If element is smaller than mid, then    // it can only be present in left subarray    if (arr[mid] > x)        return binarySearch(arr, l, mid - 1, x);     // Else the element can only be present    // in right subarray    return binarySearch(arr, mid + 1, r, x);} // Returns number of times x occurs in arr[0..n-1]int countOccurrences(int arr[], int n, int x){    int ind = binarySearch(arr, 0, n - 1, x);     // If element is not present    if (ind == -1)        return 0;     // Count elements on left side.    int count = 1;    int left = ind - 1;    while (left >= 0 && arr[left] == x)        count++, left--;     // Count elements on right side.    int right = ind + 1;    while (right < n && arr[right] == x)        count++, right++;     return count;} // Driver codeint main(){    int arr[] = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };    int n = sizeof(arr) / sizeof(arr[0]);    int x = 2;    cout << countOccurrences(arr, n, x);    return 0;}
// Java program to count// occurrences of an elementclass GFG{     // A recursive binary search    // function. It returns location    // of x in given array arr[l..r]    // is present, otherwise -1    static int binarySearch(int arr[], int l,                            int r, int x)    {        if (r < l)            return -1;         int mid = l + (r - l) / 2;         // If the element is present        // at the middle itself        if (arr[mid] == x)            return mid;         // If element is smaller than        // mid, then it can only be        // present in left subarray        if (arr[mid] > x)            return binarySearch(arr, l,                                mid - 1, x);         // Else the element can        // only be present in        // right subarray        return binarySearch(arr, mid + 1, r, x);    }     // Returns number of times x    // occurs in arr[0..n-1]    static int countOccurrences(int arr[],                                int n, int x)    {        int ind = binarySearch(arr, 0,                               n - 1, x);         // If element is not present        if (ind == -1)            return 0;         // Count elements on left side.        int count = 1;        int left = ind - 1;        while (left >= 0 &&               arr[left] == x)        {            count++;            left--;        }         // Count elements        // on right side.        int right = ind + 1;        while (right < n &&               arr[right] == x)        {            count++;            right++;        }         return count;    }      // Driver code    public static void main(String[] args)    {        int arr[] = {1, 2, 2, 2, 2,                     3, 4, 7, 8, 8};        int n = arr.length;        int x = 2;        System.out.print(countOccurrences(arr, n, x));    }} // This code is contributed// by ChitraNayal
# Python 3 program to count# occurrences of an element # A recursive binary search# function. It returns location# of x in given array arr[l..r]# is present, otherwise -1def binarySearch(arr, l, r, x):    if (r < l):        return -1     mid = int( l + (r - l) / 2)     # If the element is present    # at the middle itself    if arr[mid] == x:        return mid     # If element is smaller than    # mid, then it can only be    # present in left subarray    if arr[mid] > x:        return binarySearch(arr, l,                            mid - 1, x)     # Else the element    # can only be present    # in right subarray    return binarySearch(arr, mid + 1,                                r, x) # Returns number of times# x occurs in arr[0..n-1]def countOccurrences(arr, n, x):    ind = binarySearch(arr, 0, n - 1, x)     # If element is not present    if ind == -1:        return 0     # Count elements    # on left side.    count = 1    left = ind - 1    while (left >= 0 and           arr[left] == x):        count += 1        left -= 1     # Count elements on    # right side.    right = ind + 1;    while (right < n and           arr[right] == x):        count += 1        right += 1     return count # Driver codearr = [ 1, 2, 2, 2, 2,        3, 4, 7, 8, 8 ]n = len(arr)x = 2print(countOccurrences(arr, n, x)) # This code is contributed# by ChitraNayal
// C# program to count// occurrences of an elementusing System; class GFG{     // A recursive binary search    // function. It returns location    // of x in given array arr[l..r]    // is present, otherwise -1    static int binarySearch(int[] arr, int l,                            int r, int x)    {        if (r < l)            return -1;         int mid = l + (r - l) / 2;         // If the element is present        // at the middle itself        if (arr[mid] == x)            return mid;         // If element is smaller than        // mid, then it can only be        // present in left subarray        if (arr[mid] > x)            return binarySearch(arr, l,                                mid - 1, x);         // Else the element        // can only be present        // in right subarray        return binarySearch(arr, mid + 1,                                   r, x);    }     // Returns number of times x    // occurs in arr[0..n-1]    static int countOccurrences(int[] arr,                                int n, int x)    {        int ind = binarySearch(arr, 0,                               n - 1, x);         // If element is not present        if (ind == -1)            return 0;         // Count elements on left side.        int count = 1;        int left = ind - 1;        while (left >= 0 &&               arr[left] == x)        {            count++;            left--;        }         // Count elements on right side.        int right = ind + 1;        while (right < n &&               arr[right] == x)        {            count++;            right++;        }         return count;    }      // Driver code    public static void Main()    {        int[] arr = {1, 2, 2, 2, 2,                     3, 4, 7, 8, 8};        int n = arr.Length;        int x = 2;        Console.Write(countOccurrences(arr, n, x));    }} // This code is contributed// by ChitraNayal
<?php// PHP program to count// occurrences of an element // A recursive binary search// function. It returns location// of x in given array arr[l..r]// is present, otherwise -1function binarySearch(&$arr, $l,                         $r, $x){    if ($r < $l)        return -1;     $mid = $l + ($r - $l) / 2;     // If the element is present    // at the middle itself    if ($arr[$mid] == $x)        return $mid;     // If element is smaller than    // mid, then it can only be    // present in left subarray    if ($arr[$mid] > $x)        return binarySearch($arr, $l,                              $mid - 1, $x);     // Else the element    // can only be present    // in right subarray    return binarySearch($arr, $mid + 1,                                $r, $x);} // Returns number of times// x occurs in arr[0..n-1]function countOccurrences($arr, $n, $x){    $ind = binarySearch($arr, 0,                        $n - 1, $x);     // If element is not present    if ($ind == -1)        return 0;     // Count elements    // on left side.    $count = 1;    $left = $ind - 1;    while ($left >= 0 &&           $arr[$left] == $x)    {        $count++;        $left--;    }         // Count elements on right side.    $right = $ind + 1;    while ($right < $n &&           $arr[$right] == $x)    {        $count++;        $right++;    }    return $count;} // Driver code$arr = array( 1, 2, 2, 2, 2,              3, 4, 7, 8, 8 );$n = sizeof($arr);$x = 2;echo countOccurrences($arr, $n, $x); // This code is contributed// by ChitraNayal?>
<script> // Javascript program to count occurrences of an element // A recursive binary search function. It returns// location of x in given array arr[l..r] is present,// otherwise -1function binarySearch(arr, l, r, x){    if (r < l)        return -1;     var mid = l + parseInt((r - l) / 2);     // If the element is present at the middle    // itself    if (arr[mid] == x)        return mid;     // If element is smaller than mid, then    // it can only be present in left subarray    if (arr[mid] > x)        return binarySearch(arr, l, mid - 1, x);     // Else the element can only be present    // in right subarray    return binarySearch(arr, mid + 1, r, x);} // Returns number of times x occurs in arr[0..n-1]function countOccurrences(arr, n, x){    var ind = binarySearch(arr, 0, n - 1, x);     // If element is not present    if (ind == -1)        return 0;     // Count elements on left side.    var count = 1;    var left = ind - 1;    while (left >= 0 && arr[left] == x)        count++, left--;     // Count elements on right side.    var right = ind + 1;    while (right < n && arr[right] == x)        count++, right++;     return count;} // Driver codevar arr = [ 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 ];var n = arr.length;var x = 2;document.write(countOccurrences(arr, n, x)); // This code is contributed by noob2000.</script>
Output : 
4
Time Complexity : O(Log n + count) where count is number of occurrences. Method 3 (Best using Improved Binary Search) 1) Use Binary search to get index of the first occurrence of x in arr[]. Let the index of the first occurrence be i. 2) Use Binary search to get index of the last occurrence of x in arr[]. Let the index of the last occurrence be j. 3) Return (j – i + 1);
C++
C
Java
Python3
C#
Javascript
// C++ program to count occurrences of an element// in a sorted array.# include <bits/stdc++.h>using namespace std; /* if x is present in arr[] then returns the count    of occurrences of x, otherwise returns 0. */int count(int arr[], int x, int n){     /* get the index of first occurrence of x */  int *low = lower_bound(arr, arr+n, x);   // If element is not present, return 0  if (low == (arr + n) || *low != x)     return 0;      /* Else get the index of last occurrence of x.     Note that we  are only looking in the     subarray after first occurrence */    int *high = upper_bound(low, arr+n, x);          /* return count */  return high - low;} /* driver program to test above functions */int main(){  int arr[] = {1, 2, 2, 3, 3, 3, 3};  int x =  3;  // Element to be counted in arr[]  int n = sizeof(arr)/sizeof(arr[0]);  int c = count(arr, x, n);  printf(" %d occurs %d times ", x, c);  return 0;}
# include <stdio.h> /* if x is present in arr[] then returns   the index of FIRST occurrence   of x in arr[0..n-1], otherwise returns -1 */int first(int arr[], int low, int high, int x, int n){  if(high >= low)  {    int mid = (low + high)/2;  /*low + (high - low)/2;*/    if( ( mid == 0 || x > arr[mid-1]) && arr[mid] == x)      return mid;    else if(x > arr[mid])      return first(arr, (mid + 1), high, x, n);    else      return first(arr, low, (mid -1), x, n);  }  return -1;} /* if x is present in arr[] then returns the   index of LAST occurrence of x in arr[0..n-1],   otherwise returns -1 */int last(int arr[], int low, int high, int x, int n){  if (high >= low)  {    int mid = (low + high)/2;  /*low + (high - low)/2;*/    if( ( mid == n-1 || x < arr[mid+1]) && arr[mid] == x )      return mid;    else if(x < arr[mid])      return last(arr, low, (mid -1), x, n);    else      return last(arr, (mid + 1), high, x, n);       }  return -1;} /* if x is present in arr[] then returns the count   of occurrences of x, otherwise returns -1. */int count(int arr[], int x, int n){  int i; // index of first occurrence of x in arr[0..n-1]  int j; // index of last occurrence of x in arr[0..n-1]       /* get the index of first occurrence of x */  i = first(arr, 0, n-1, x, n);   /* If x doesn't exist in arr[] then return -1 */  if(i == -1)    return i;      /* Else get the index of last occurrence of x.     Note that we are only looking in the subarray     after first occurrence */    j = last(arr, i, n-1, x, n);          /* return count */  return j-i+1;} /* driver program to test above functions */int main(){  int arr[] = {1, 2, 2, 3, 3, 3, 3};  int x =  3;  // Element to be counted in arr[]  int n = sizeof(arr)/sizeof(arr[0]);  int c = count(arr, x, n);  printf(" %d occurs %d times ", x, c);  getchar();  return 0;}
// Java program to count occurrences// of an element class Main{    /* if x is present in arr[] then returns       the count of occurrences of x,       otherwise returns -1. */    static int count(int arr[], int x, int n)    {      // index of first occurrence of x in arr[0..n-1]         int i;             // index of last occurrence of x in arr[0..n-1]      int j;                /* get the index of first occurrence of x */      i = first(arr, 0, n-1, x, n);            /* If x doesn't exist in arr[] then return -1 */      if(i == -1)        return i;               /* Else get the index of last occurrence of x.         Note that we are only looking in the         subarray after first occurrence */       j = last(arr, i, n-1, x, n);                   /* return count */      return j-i+1;    }          /* if x is present in arr[] then returns the       index of FIRST occurrence of x in arr[0..n-1],       otherwise returns -1 */    static int first(int arr[], int low, int high, int x, int n)    {      if(high >= low)      {        /*low + (high - low)/2;*/         int mid = (low + high)/2;         if( ( mid == 0 || x > arr[mid-1]) && arr[mid] == x)          return mid;        else if(x > arr[mid])          return first(arr, (mid + 1), high, x, n);        else          return first(arr, low, (mid -1), x, n);      }      return -1;    }          /* if x is present in arr[] then returns the       index of LAST occurrence of x in arr[0..n-1],       otherwise returns -1 */    static int last(int arr[], int low, int high, int x, int n)    {      if(high >= low)      {        /*low + (high - low)/2;*/             int mid = (low + high)/2;        if( ( mid == n-1 || x < arr[mid+1]) && arr[mid] == x )          return mid;        else if(x < arr[mid])          return last(arr, low, (mid -1), x, n);        else          return last(arr, (mid + 1), high, x, n);           }      return -1;    }          public static void main(String args[])    {        int arr[] = {1, 2, 2, 3, 3, 3, 3};                 // Element to be counted in arr[]        int x =  3;        int n = arr.length;        int c = count(arr, x, n);        System.out.println(x+" occurs "+c+" times");    }}
# Python3 program to count# occurrences of an element # if x is present in arr[] then# returns the count of occurrences# of x, otherwise returns -1.def count(arr, x, n):     # get the index of first    # occurrence of x    i = first(arr, 0, n-1, x, n)      # If x doesn't exist in    # arr[] then return -1    if i == -1:        return i         # Else get the index of last occurrence    # of x. Note that we are only looking    # in the subarray after first occurrence      j = last(arr, i, n-1, x, n);             # return count    return j-i+1; # if x is present in arr[] then return# the index of FIRST occurrence of x in# arr[0..n-1], otherwise returns -1def first(arr, low, high, x, n):    if high >= low:         # low + (high - low)/2        mid = (low + high)//2                      if (mid == 0 or x > arr[mid-1]) and arr[mid] == x:            return mid        elif x > arr[mid]:            return first(arr, (mid + 1), high, x, n)        else:            return first(arr, low, (mid -1), x, n)    return -1;  # if x is present in arr[] then return# the index of LAST occurrence of x# in arr[0..n-1], otherwise returns -1def last(arr, low, high, x, n):    if high >= low:         # low + (high - low)/2        mid = (low + high)//2;          if(mid == n-1 or x < arr[mid+1]) and arr[mid] == x :            return mid        elif x < arr[mid]:            return last(arr, low, (mid -1), x, n)        else:            return last(arr, (mid + 1), high, x, n)        return -1 # driver program to test above functionsarr = [1, 2, 2, 3, 3, 3, 3]x = 3  # Element to be counted in arr[]n = len(arr)c = count(arr, x, n)print ("%d occurs %d times "%(x, c))
// C# program to count occurrences// of an elementusing System; class GFG{         /* if x is present in arr[] then returns    the count of occurrences of x,    otherwise returns -1. */    static int count(int []arr, int x, int n)    {    // index of first occurrence of x in arr[0..n-1]    int i;             // index of last occurrence of x in arr[0..n-1]    int j;             /* get the index of first occurrence of x */    i = first(arr, 0, n-1, x, n);         /* If x doesn't exist in arr[] then return -1 */    if(i == -1)        return i;             /* Else get the index of last occurrence of x.        Note that we are only looking in the        subarray after first occurrence */    j = last(arr, i, n-1, x, n);                 /* return count */    return j-i+1;    }         /* if x is present in arr[] then returns the    index of FIRST occurrence of x in arr[0..n-1],    otherwise returns -1 */    static int first(int []arr, int low, int high,                                     int x, int n)    {    if(high >= low)    {        /*low + (high - low)/2;*/        int mid = (low + high)/2;        if( ( mid == 0 || x > arr[mid-1])                            && arr[mid] == x)        return mid;        else if(x > arr[mid])        return first(arr, (mid + 1), high, x, n);        else        return first(arr, low, (mid -1), x, n);    }    return -1;    }         /* if x is present in arr[] then returns the    index of LAST occurrence of x in arr[0..n-1],    otherwise returns -1 */    static int last(int []arr, int low,                        int high, int x, int n)    {    if(high >= low)    {        /*low + (high - low)/2;*/           int mid = (low + high)/2;        if( ( mid == n-1 || x < arr[mid+1])                            && arr[mid] == x )        return mid;        else if(x < arr[mid])        return last(arr, low, (mid -1), x, n);        else        return last(arr, (mid + 1), high, x, n);        }    return -1;    }         public static void Main()    {        int []arr = {1, 2, 2, 3, 3, 3, 3};                 // Element to be counted in arr[]        int x = 3;        int n = arr.Length;        int c = count(arr, x, n);                 Console.Write(x + " occurs " + c + " times");    }}// This code is contributed by Sam007
<script> // Javascript program to count occurrences// of an element /* if x is present in arr[] then returnsthe count of occurrences of x,otherwise returns -1. */function count(arr, x, n){         // Index of first occurrence of x in arr[0..n-1]       let i;         // Index of last occurrence of x in arr[0..n-1]    let j;         // Get the index of first occurrence of x    i = first(arr, 0, n - 1, x, n);         // If x doesn't exist in arr[] then return -1    if (i == -1)        return i;         // Else get the index of last occurrence of x.    // Note that we are only looking in the    // subarray after first occurrence    j = last(arr, i, n - 1, x, n);             // return count    return j - i + 1;}     // if x is present in arr[] then returns the// index of FIRST occurrence of x in arr[0..n-1],// otherwise returns -1function first(arr, low, high, x, n){    if (high >= low)    {                 // low + (high - low)/2;        let mid = (low + high) / 2;                  if ((mid == 0 || x > arr[mid - 1]) &&        arr[mid] == x)            return mid;        else if (x > arr[mid])            return first(arr, (mid + 1), high, x, n);        else            return first(arr, low, (mid - 1), x, n);    }    return -1;} // If x is present in arr[] then returns the// index of LAST occurrence of x in arr[0..n-1],// otherwise returns -1function last(arr, low, high, x, n){    if (high >= low)    {        /*low + (high - low)/2;*/             let mid = Math.floor((low + high) / 2);        if ((mid == n - 1 || x < arr[mid + 1]) &&        arr[mid] == x)            return mid;        else if (x < arr[mid])            return last(arr, low, (mid - 1), x, n);        else            return last(arr, (mid + 1), high, x, n);         }    return -1;} // Driver codelet arr = [ 1, 2, 2, 3, 3, 3, 3 ]; // Element to be counted in arr[]let x =  3;let n = arr.length;let c = count(arr, x, n); document.write(x + " occurs " + c + " times"); // This code is contributed by target_2 </script>
Output:  
3 occurs 4 times
Time Complexity: O(Logn) Programming Paradigm: Divide & Conquer
Using Collections.frequency() method of java
Java
C#
Javascript
/*package whatever //do not write package name here */import java.util.ArrayList;import java.util.Collections; public class GFG {       // Function to count occurrences    static int countOccurrences(ArrayList<Integer> clist,                                int x)    {        // returning the frequency of        // element x in the ArrayList        // using Collections.frequency() method        return Collections.frequency(clist, x);    }     // Driver Code    public static void main(String args[])    {        int arr[] = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };        int x = 2;        ArrayList<Integer> clist = new ArrayList<>();         // adding elements of array to        // ArrayList        for (int i : arr)            clist.add(i);         // displaying the frequency of x in ArrayList        System.out.println(x + " occurs "                           + countOccurrences(clist, x)                           + " times");    }}
// C# program for the above approachusing System; public class GFG{     // Function to count occurrences    static int countOccurrences(int[] arr,                                int x)    {        int count = 0;        int n = arr.Length;        for (int i=0; i < n; i++)        if (arr[i] == x)            count++;        return count;    }          // Driver Code    public static void Main (string[] args)    {        int[] arr = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };        int x = 2;          // displaying the frequency of x in ArrayList        Console.WriteLine(x + " occurs "                           + countOccurrences(arr, x)                           + " times");      }} // This code is contributed by avijitmondal1998.
<script> // javascript program for above approach     // Function to count occurrences    function countOccurrences(arr, x)    {        let count = 0;        let n = arr.length;        for (let i=0; i < n; i++)        if (arr[i] == x)            count++;        return count;    }      // Driver Code    let arr = [ 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 ];    let x = 2;      // displaying the frequency of x in ArrayList    document.write(x + " occurs "                     + countOccurrences(arr, x)                        + " times"); // This code is contributed by splevel62.</script>
Output:
2 occurs 4 times
YouTubeGeeksforGeeks502K subscribersCount number of occurrences (or frequency) in a sorted array | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 3:56•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=G2qGmOyDzCY" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
Please write comments if you find the above codes/algorithms incorrect, or find other ways to solve the same problem. 
Sam007
ukasp
le0
avanitrachhadiya2155
swplucky
noob2000
target_2
avijitmondal1998
splevel62
Amazon
MakeMyTrip
Arrays
Divide and Conquer
Searching
Amazon
MakeMyTrip
Arrays
Searching
Divide and Conquer
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Multidimensional Arrays in Java
Introduction to Arrays
Linear Search
Merge Sort
QuickSort
Binary Search
Maximum and minimum of an array using minimum number of comparisons
Program for Tower of Hanoi