Find a peak element - GeeksforGeeks

28 Apr, 2022
Given an array of integers. Find a peak element in it. An array element is a peak if it is NOT smaller than its neighbours. For corner elements, we need to consider only one neighbour. 
Example:
Input: array[]= {5, 10, 20, 15}
Output: 20
The element 20 has neighbours 10 and 15,
both of them are less than 20.

Input: array[] = {10, 20, 15, 2, 23, 90, 67}
Output: 20 or 90
The element 20 has neighbours 10 and 15, 
both of them are less than 20, similarly 90 has neighbours 23 and 67.
Following corner cases give better idea about the problem. 
If input array is sorted in strictly increasing order, the last element is always a peak element. For example, 50 is peak element in {10, 20, 30, 40, 50}.If the input array is sorted in strictly decreasing order, the first element is always a peak element. 100 is the peak element in {100, 80, 60, 50, 20}.If all elements of input array are same, every element is a peak element.
If input array is sorted in strictly increasing order, the last element is always a peak element. For example, 50 is peak element in {10, 20, 30, 40, 50}.
If the input array is sorted in strictly decreasing order, the first element is always a peak element. 100 is the peak element in {100, 80, 60, 50, 20}.
If all elements of input array are same, every element is a peak element.
It is clear from the above examples that there is always a peak element in the input array.
Naive Approach: The array can be traversed and the element whose neighbours are less than that element can be returned.Algorithm: 
If in the array, the first element is greater than the second or the last element is greater than the second last, print the respective element and terminate the program.Else traverse the array from the second index to the second last indexIf for an element array[i], it is greater than both its neighbours, i.e., array[i] > array[i-1] and array[i] > array[i+1], then print that element and terminate.
If in the array, the first element is greater than the second or the last element is greater than the second last, print the respective element and terminate the program.
Else traverse the array from the second index to the second last index
If for an element array[i], it is greater than both its neighbours, i.e., array[i] > array[i-1] and array[i] > array[i+1], then print that element and terminate.
C++
C
Java
Python3
C#
Javascript
// A C++ program to find a peak element#include <bits/stdc++.h>using namespace std; // Find the peak element in the arrayint findPeak(int arr[], int n){    // first or last element is peak element    if (n == 1)        return 0;    if (arr[0] >= arr[1])        return 0;    if (arr[n - 1] >= arr[n - 2])        return n - 1;     // check for every other element    for (int i = 1; i < n - 1; i++) {         // check if the neighbors are smaller        if (arr[i] >= arr[i - 1] && arr[i] >= arr[i + 1])            return i;    }} // Driver Codeint main(){    int arr[] = { 1, 3, 20, 4, 1, 0 };    int n = sizeof(arr) / sizeof(arr[0]);    cout << "Index of a peak point is " << findPeak(arr, n);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// A C program to find a peak element#include <stdio.h> // Find the peak element in the arrayint findPeak(int arr[], int n){    // first or last element is peak element    if (n == 1)        return 0;    if (arr[0] >= arr[1])        return 0;    if (arr[n - 1] >= arr[n - 2])        return n - 1;     // check for every other element    for (int i = 1; i < n - 1; i++) {         // check if the neighbors are smaller        if (arr[i] >= arr[i - 1] && arr[i] >= arr[i + 1])            return i;    }} // Driver Codeint main(){    int arr[] = { 1, 3, 20, 4, 1, 0 };    int n = sizeof(arr) / sizeof(arr[0]);    printf("Index of a peak point is %d",findPeak(arr, n));    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// A Java program to find a peak elementimport java.util.*; class GFG {     // Find the peak element in the array    static int findPeak(int arr[], int n)    {        // First or last element is peak element        if (n == 1)            return 0;        if (arr[0] >= arr[1])            return 0;        if (arr[n - 1] >= arr[n - 2])            return n - 1;        // Check for every other element        for (int i = 1; i < n - 1; i++) {            // Check if the neighbors are smaller            if (arr[i] >= arr[i - 1] && arr[i] >= arr[i + 1])                return i;        }        return 0;    }     // Driver Code    public static void main(String[] args)    {        int arr[] = { 1, 3, 20, 4, 1, 0 };        int n = arr.length;        System.out.print("Index of a peak point is " + findPeak(arr, n));    }} // This code is contributed by Aditya Kumar (adityakumar129)
# A Python3 program to find a peak element # Find the peak element in the arraydef findPeak(arr, n) :     # first or last element is peak element    if (n == 1) :      return 0    if (arr[0] >= arr[1]) :        return 0    if (arr[n - 1] >= arr[n - 2]) :        return n - 1      # check for every other element    for i in range(1, n - 1) :          # check if the neighbors are smaller        if (arr[i] >= arr[i - 1] and arr[i] >= arr[i + 1]) :            return i             # Driver code.arr = [ 1, 3, 20, 4, 1, 0 ]n = len(arr)print("Index of a peak point is", findPeak(arr, n)) # This code is contributed by divyeshrabadiya07
// A C# program to find a peak elementusing System; public class GFG{ // Find the peak element in the arraystatic int findPeak(int []arr, int n){         // First or last element is peak element    if (n == 1)      return 0;    if (arr[0] >= arr[1])        return 0;    if (arr[n - 1] >= arr[n - 2])        return n - 1;     // Check for every other element    for(int i = 1; i < n - 1; i++)    {                 // Check if the neighbors are smaller        if (arr[i] >= arr[i - 1] &&            arr[i] >= arr[i + 1])            return i;    }    return 0;} // Driver Codepublic static void Main(String[] args){    int []arr = { 1, 3, 20, 4, 1, 0 };    int n = arr.Length;         Console.Write("Index of a peak point is " +                     findPeak(arr, n));}}    // This code is contributed by 29AjayKumar
<script>      // A JavaScript program to find a peak element       // Find the peak element in the array      function findPeak(arr, n)      {               // first or last element is peak element        if (n == 1) return 0;        if (arr[0] >= arr[1]) return 0;        if (arr[n - 1] >= arr[n - 2]) return n - 1;         // check for every other element        for (var i = 1; i < n - 1; i++)        {                   // check if the neighbors are smaller          if (arr[i] >= arr[i - 1] && arr[i] >= arr[i + 1]) return i;        }      }       // Driver Code      var arr = [1, 3, 20, 4, 1, 0];      var n = arr.length;      document.write("Index of a peak point is " + findPeak(arr, n));             // This code is contributed by rdtank.    </script>
Output: 
Index of a peak point is 2
Complexity Analysis: 
Time complexity: O(n). One traversal is needed so the time complexity is O(n)
Space Complexity: O(1). No extra space is needed, so space complexity is constant
Efficient Approach: Divide and Conquer can be used to find a peak in O(Logn) time. The idea is based on the technique of Binary Search to check if the middle element is the peak element or not. If the middle element is not the peak element, then check if the element on the right side is greater than the middle element then there is always a peak element on the right side. If the element on the left side is greater than the middle element then there is always a peak element on the left side. Form a recursion and the peak element can be found in log n time. 
Algorithm: 
Create two variables, l and r, initialize l = 0 and r = n-1Iterate the steps below till l <= r, lowerbound is less than the upperboundCheck if the mid value or index mid = (l+r)/2, is the peak element or not, if yes then print the element and terminate.Else if the element on the left side of the middle element is greater then check for peak element on the left side, i.e. update r = mid – 1Else if the element on the right side of the middle element is greater then check for peak element on the right side, i.e. update l = mid + 1
Create two variables, l and r, initialize l = 0 and r = n-1
Iterate the steps below till l <= r, lowerbound is less than the upperbound
Check if the mid value or index mid = (l+r)/2, is the peak element or not, if yes then print the element and terminate.
Else if the element on the left side of the middle element is greater then check for peak element on the left side, i.e. update r = mid – 1
Else if the element on the right side of the middle element is greater then check for peak element on the right side, i.e. update l = mid + 1
C++
C
Java
Python3
C#
PHP
Javascript
// A C++ program to find a peak element// using divide and conquer#include <bits/stdc++.h>using namespace std; // A binary search based function// that returns index of a peak elementint findPeakUtil(int arr[], int low,                 int high, int n){    // Find index of middle element    // (low + high)/2    int mid = low + (high - low) / 2;     // Compare middle element with its    // neighbours (if neighbours exist)    if ((mid == 0 || arr[mid - 1] <= arr[mid]) &&        (mid == n - 1 || arr[mid + 1] <= arr[mid]))        return mid;     // If middle element is not peak and its    // left neighbour is greater than it,    // then left half must have a peak element    else if (mid > 0 && arr[mid - 1] > arr[mid])        return findPeakUtil(arr, low, (mid - 1), n);     // If middle element is not peak and its    // right neighbour is greater than it,    // then right half must have a peak element    else        return findPeakUtil(            arr, (mid + 1), high, n);} // A wrapper over recursive function findPeakUtil()int findPeak(int arr[], int n){    return findPeakUtil(arr, 0, n - 1, n);} // Driver Codeint main(){    int arr[] = { 1, 3, 20, 4, 1, 0 };    int n = sizeof(arr) / sizeof(arr[0]);    cout << "Index of a peak point is "         << findPeak(arr, n);    return 0;} // This code is contributed by rathbhupendra
// C program to find a peak// element using divide and conquer#include <stdio.h> // A binary search based function that// returns index of a peak elementint findPeakUtil(    int arr[], int low, int high, int n){    // Find index of middle element    // (low + high)/2    int mid = low + (high - low) / 2;     // Compare middle element with    // its neighbours (if neighbours exist)    if ((mid == 0 || arr[mid - 1] <= arr[mid]) && (mid == n - 1 || arr[mid + 1] <= arr[mid]))        return mid;     // If middle element is not peak and    // its left neighbour is greater    // than it, then left half must have a peak element    else if (mid > 0 && arr[mid - 1] > arr[mid])        return findPeakUtil(arr, low, (mid - 1), n);     // If middle element is not peak and    // its right neighbour is greater    // than it, then right half must have a peak element    else        return findPeakUtil(arr, (mid + 1), high, n);} // A wrapper over recursive function findPeakUtil()int findPeak(int arr[], int n){    return findPeakUtil(arr, 0, n - 1, n);} /* Driver program to check above functions */int main(){    int arr[] = { 1, 3, 20, 4, 1, 0 };    int n = sizeof(arr) / sizeof(arr[0]);    printf(        "Index of a peak point is %d", findPeak(arr, n));    return 0;}
// A Java program to find a peak// element using divide and conquerimport java.util.*;import java.lang.*;import java.io.*; class PeakElement {    // A binary search based function    // that returns index of a peak element    static int findPeakUtil(        int arr[], int low, int high, int n)    {        // Find index of middle element        // (low + high)/2        int mid = low + (high - low) / 2;         // Compare middle element with its        // neighbours (if neighbours exist)        if ((mid == 0 || arr[mid - 1] <= arr[mid])            && (mid == n - 1 || arr[mid + 1] <= arr[mid]))            return mid;         // If middle element is not peak        // and its left neighbor is        // greater than it, then left half        // must have a peak element        else if (mid > 0 && arr[mid - 1] > arr[mid])            return findPeakUtil(arr, low, (mid - 1), n);         // If middle element is not peak        // and its right neighbor        // is greater than it, then right        // half must have a peak        // element        else            return findPeakUtil(                arr, (mid + 1), high, n);    }     // A wrapper over recursive function    // findPeakUtil()    static int findPeak(int arr[], int n)    {        return findPeakUtil(arr, 0, n - 1, n);    }     // Driver method    public static void main(String[] args)    {        int arr[] = { 1, 3, 20, 4, 1, 0 };        int n = arr.length;        System.out.println(            "Index of a peak point is " + findPeak(arr, n));    }}
# A python3 program to find a peak#  element using divide and conquer # A binary search based function# that returns index of a peak elementdef findPeakUtil(arr, low, high, n):          # Find index of middle element     # (low + high)/2     mid = low + (high - low)/2     mid = int(mid)         # Compare middle element with its    # neighbours (if neighbours exist)    if ((mid == 0 or arr[mid - 1] <= arr[mid]) and        (mid == n - 1 or arr[mid + 1] <= arr[mid])):        return mid      # If middle element is not peak and    # its left neighbour is greater    # than it, then left half must    # have a peak element    elif (mid > 0 and arr[mid - 1] > arr[mid]):        return findPeakUtil(arr, low, (mid - 1), n)     # If middle element is not peak and    # its right neighbour is greater    # than it, then right half must    # have a peak element    else:        return findPeakUtil(arr, (mid + 1), high, n)  # A wrapper over recursive# function findPeakUtil()def findPeak(arr, n):     return findPeakUtil(arr, 0, n - 1, n)  # Driver codearr = [1, 3, 20, 4, 1, 0]n = len(arr)print("Index of a peak point is", findPeak(arr, n))     # This code is contributed by# Smitha Dinesh Semwal
// A C# program to find// a peak element// using divide and conquerusing System; class GFG {     // A binary search based    // function that returns    // index of a peak element    static int findPeakUtil(int[] arr, int low,                            int high, int n)    {        // Find index of        // middle element        int mid = low + (high - low) / 2;         // Compare middle element with        // its neighbours (if neighbours        // exist)        if ((mid == 0 || arr[mid - 1] <= arr[mid]) && (mid == n - 1 || arr[mid + 1] <= arr[mid]))            return mid;         // If middle element is not        // peak and its left neighbor        // is greater than it, then        // left half must have a        // peak element        else if (mid > 0 && arr[mid - 1] > arr[mid])            return findPeakUtil(arr, low,                                (mid - 1), n);         // If middle element is not        // peak and its right neighbor        // is greater than it, then        // right half must have a peak        // element        else            return findPeakUtil(arr, (mid + 1),                                high, n);    }     // A wrapper over recursive    // function findPeakUtil()    static int findPeak(int[] arr,                        int n)    {        return findPeakUtil(arr, 0,                            n - 1, n);    }     // Driver Code    static public void Main()    {        int[] arr = { 1, 3, 20,                      4, 1, 0 };        int n = arr.Length;        Console.WriteLine("Index of a peak "                          + "point is " + findPeak(arr, n));    }} // This code is contributed by ajit
<?php// A PHP program to find a// peak element  using// divide and conquer // A binary search based function// that returns index of a peak// elementfunction findPeakUtil($arr, $low,                      $high, $n){    // Find index of middle element    $mid = $low + ($high - $low) / 2; // (low + high)/2     // Compare middle element with    // its neighbours (if neighbours exist)    if (($mid == 0 ||         $arr[$mid - 1] <= $arr[$mid]) &&        ($mid == $n - 1 ||         $arr[$mid + 1] <= $arr[$mid]))        return $mid;     // If middle element is not peak    // and its left neighbour is greater    // than it, then left half must    // have a peak element    else if ($mid > 0 &&             $arr[$mid - 1] > $arr[$mid])        return findPeakUtil($arr, $low,                           ($mid - 1), $n);     // If middle element is not peak    // and its right neighbour is    // greater than it, then right    // half must have a peak element    else return(findPeakUtil($arr, ($mid + 1),                             $high, $n));} // A wrapper over recursive// function findPeakUtil()function findPeak($arr, $n){    return floor(findPeakUtil($arr, 0,                              $n - 1, $n));} // Driver Code$arr = array(1, 3, 20, 4, 1, 0);$n = sizeof($arr);echo "Index of a peak point is ",              findPeak($arr, $n); // This code is contributed by ajit?>
<script> // A Javascript program to find a peak element// using divide and conquer // A binary search based function// that returns index of a peak elementfunction findPeakUtil(arr, low, high, n){    // Find index of middle element    // (low + high)/2    var mid = low + parseInt((high - low) / 2);     // Compare middle element with its    // neighbours (if neighbours exist)    if ((mid == 0 || arr[mid - 1] <= arr[mid]) &&        (mid == n - 1 || arr[mid + 1] <= arr[mid]))        return mid;     // If middle element is not peak and its    // left neighbour is greater than it,    // then left half must have a peak element    else if (mid > 0 && arr[mid - 1] > arr[mid])        return findPeakUtil(arr, low, (mid - 1), n);     // If middle element is not peak and its    // right neighbour is greater than it,    // then right half must have a peak element    else        return findPeakUtil(            arr, (mid + 1), high, n);} // A wrapper over recursive function findPeakUtil() function findPeak(arr, n){    return findPeakUtil(arr, 0, n - 1, n);} // Driver Codevar arr = [ 1, 3, 20, 4, 1, 0 ];var n = arr.length;document.write("Index of a peak point is "    + findPeak(arr, n));  </script>
Output: 
Index of a peak point is 2
Complexity Analysis: 
Time Complexity: O(Logn). Where n is the number of elements in the input array. In each step our search becomes half. So it can be compared to Binary search, So the time complexity is O(log n)
Space complexity: O(1). No extra space is required, so the space complexity is constant.
Iterative Approach : The below given code is the iterative version of the above explained and demonstrated recursive based divide and conquer technique.
C++
C
Java
Python3
C#
Javascript
// A C++ program to find a peak element// using divide and conquer#include <bits/stdc++.h>using namespace std; // A binary search based function// that returns index of a peak elementint findPeakUtil(int arr[], int low, int high, int n){    int l = low;    int r = high;    int mid;    while (l <= r) {        // finding mid by binary right shifting.        mid = (l + r) >> 1;        // first case if mid is the answer        if ((mid == 0 || arr[mid - 1] <= arr[mid])            and (mid == n - 1 || arr[mid + 1] <= arr[mid]))            break;        // if we have to perform left recursion        if (mid > 0 and arr[mid - 1] > arr[mid])            r = mid - 1;        // else right recursion.        else            l = mid + 1;    }    return mid;} // A wrapper over recursive function findPeakUtil()int findPeak(int arr[], int n){    return findPeakUtil(arr, 0, n - 1, n);} // Driver Codeint main(){    int arr[] = { 1, 3, 20, 4, 1, 0 };    int n = sizeof(arr) / sizeof(arr[0]);    cout << "Index of a peak point is " << findPeak(arr, n);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// A C program to find a peak element using divide and// conquer#include <stdio.h> // A binary search based function// that returns index of a peak elementint findPeakUtil(int arr[], int low, int high, int n){    int l = low;    int r = high;    int mid;    while (l <= r) {        // finding mid by binary right shifting.        mid = (l + r) >> 1;        // first case if mid is the answer        if ((mid == 0 || arr[mid - 1] <= arr[mid])            && (mid == n - 1 || arr[mid + 1] <= arr[mid]))            break;        // if we have to perform left recursion        if (mid > 0 && arr[mid - 1] > arr[mid])            r = mid - 1;        // else right recursion.        else            l = mid + 1;    }    return mid;} // A wrapper over recursive function findPeakUtil()int findPeak(int arr[], int n){    return findPeakUtil(arr, 0, n - 1, n);} // Driver Codeint main(){    int arr[] = { 1, 3, 20, 4, 1, 0 };    int n = sizeof(arr) / sizeof(arr[0]);    printf("Index of a peak point is %d", findPeak(arr, n));    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// A Java program to find a peak element using divide and// conquerclass GFG {     // A binary search based function that returns index of    // a peak element    static int findPeakUtil(int arr[], int low, int high, int n)    {        int l = low;        int r = high;        int mid = 0;        while (l <= r) {             // finding mid by binary right shifting.            mid = (l + r) >> 1;             // first case if mid is the answer            if ((mid == 0 || arr[mid - 1] <= arr[mid]            && (mid == n - 1 || arr[mid + 1] <= arr[mid])))                break;             // if we have to perform left recursion            if (mid > 0 && arr[mid - 1] > arr[mid])                r = mid - 1;             // else right recursion.            else                l = mid + 1;        }        return mid;    }     // A wrapper over recursive function findPeakUtil()    static int findPeak(int arr[], int n)    {        return findPeakUtil(arr, 0, n - 1, n);    }     // Driver Code    public static void main(String args[])    {        int arr[] = { 1, 3, 20, 4, 1, 0 };        int n = arr.length;        System.out.println("Index of a peak point is " + findPeak(arr, n));    }} // This code is contributed by Aditya Kumar (adityakumar129)
# A Python program to find a peak element# using divide and conquer # A binary search based function# that returns index of a peak elementdef findPeakUtil(arr, low, high, n):     l = low    r = high    while(l <= r):             # finding mid by binary right shifting.        mid = (l + r)>>1                    # first case if mid is the answer        if((mid == 0 or arr[mid - 1] <= arr[mid]) and (mid == n - 1 or arr[mid + 1] <= arr[mid])):            break                       # if we have to perform left recursion        if(mid > 0 and arr[mid - 1] > arr[mid]):            r = mid - 1                       # else right recursion.        else:            l = mid + 1     return mid # A wrapper over recursive function findPeakUtil()def findPeak(arr, n):    return findPeakUtil(arr, 0, n - 1, n) # Driver Codearr = [ 1, 3, 20, 4, 1, 0 ]n = len(arr)print(f"Index of a peak point is {findPeak(arr, n)}") # This code is contributed by shinjanpatra
// A C# program to find a peak element// using divide and conquerusing System; public class GFG{   // A binary search based function  // that returns index of a peak element  static int findPeakUtil(int []arr, int low, int high, int n) {    int l = low;    int r = high;    int mid = 0;    while (l <= r)    {       // finding mid by binary right shifting.      mid = (l + r) >> 1;       // first case if mid is the answer      if ((mid == 0 || arr[mid - 1] <= arr[mid] &&           (mid == n - 1 || arr[mid + 1] <= arr[mid])))        break;       // if we have to perform left recursion      if (mid > 0 && arr[mid - 1] > arr[mid])        r = mid - 1;       // else right recursion.      else        l = mid + 1;    }    return mid;  }   // A wrapper over recursive function findPeakUtil()  static int findPeak(int []arr, int n) {    return findPeakUtil(arr, 0, n - 1, n);  }   // Driver Code  public static void Main(String []args) {    int []arr = { 1, 3, 20, 4, 1, 0 };    int n = arr.Length;    Console.WriteLine("Index of a peak point is " + findPeak(arr, n));  }} // This code is contributed by shikhasingrajput
<script> // A JavaScript program to find a peak element// using divide and conquer // A binary search based function// that returns index of a peak elementfunction findPeakUtil(arr,low,high,n){    let l = low;    let r = high;    let mid;    while(l<=r)    {             // finding mid by binary right shifting.           mid = (l + r)>>1;                    // first case if mid is the answer           if((mid == 0 || arr[mid - 1] <= arr[mid]) &&           (mid == n - 1 || arr[mid + 1] <= arr[mid]))              break;                       // if we have to perform left recursion           if(mid > 0 && arr[mid - 1] > arr[mid])              r = mid - 1;                       // else right recursion.           else l = mid + 1;       }       return mid;} // A wrapper over recursive function findPeakUtil()function findPeak(arr,n){    return findPeakUtil(arr, 0, n - 1, n);} // Driver Codelet arr = [ 1, 3, 20, 4, 1, 0 ];let n = arr.length;document.write("Index of a peak point is " +findPeak(arr, n)); // This code is contributed by shinjanpatra</script>
Index of a peak point is 2
YouTubeGeeksforGeeks507K subscribersFind a Peak Element | 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 / 12:03•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=NFvAD5na5oU" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
Exercise: Consider the following modified definition of peak element. An array element is a peak if it is greater than its neighbors. Note that an array may not contain a peak element with this modified definition.
References: http://courses.csail.mit.edu/6.006/spring11/lectures/lec02.pdf http://www.youtube.com/watch?v=HtSuA80QTyo 
Related Problem: Find local minima in an arrayPlease write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
 
jit_t
ShubhamMaurya3
rathbhupendra
andrew1234
princi singh
29AjayKumar
divyeshrabadiya07
rdtank
rrrtnx
pallavisinha239
arorakashish0911
harshkumarchoudhary144
_saurabh_jaiswal
shikhasingrajput
shinjanpatra
simmytarika5
adityakumar129
Adobe
Amazon
Visa
Arrays
Divide and Conquer
Searching
Amazon
Visa
Adobe
Arrays
Searching
Divide and Conquer
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Arrays in Java
Arrays in C/C++
Write a program to reverse an array or string
Program for array rotation
Largest Sum Contiguous Subarray
Merge Sort
QuickSort
Binary Search
Program for Tower of Hanoi
Count Inversions in an array | Set 1 (Using Merge Sort)