# Find a peak element in a 2D array

• Difficulty Level : Hard
• Last Updated : 29 Apr, 2021

An element is a peak element if it is greater than or equal to its four neighbors, left, right, top and bottom. For example neighbors for A[i][j] are A[i-1][j], A[i+1][j], A[i][j-1] and A[i][j+1]. For corner elements, missing neighbors are considered of negative infinite value.
Examples:

```Input : 10 20 15
21 30 14
7  16 32
Output : 30
30 is a peak element because all its
neighbors are smaller or equal to it.
32 can also be picked as a peak.

Input : 10 7
11 17
Output : 17```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

1: A Diagonal adjacent is not considered as neighbor.
2: A peak element is not necessarily the maximal element.
3: More than one such elements can exist.
4: There is always a peak element. We can see this property by creating some matrices using pen and paper.
Method 1: (Brute Force)
Iterate through all the elements of Matrix and check if it is greater/equal to all its neighbors. If yes, return the element.
Time Complexity: O(rows * columns)
Auxiliary Space: O(1)
Method 2 : (Efficient)
This problem is mainly an extension of Find a peak element in 1D array. We apply similar Binary Search based solution here.

1. Consider mid column and find maximum element in it.
2. Let index of mid column be ‘mid’, value of maximum element in mid column be ‘max’ and maximum element be at ‘mat[max_index][mid]’.

3. If max >= A[index][mid-1] & max >= A[index][pick+1], max is a peak, return max.
4. If max < mat[max_index][mid-1], recur for left half of matrix.
5. If max < mat[max_index][mid+1], recur for right half of matrix.

Below is the implementation of above algorithm:

## C++

 `// Finding peak element in a 2D Array.``#include ``using` `namespace` `std;` `const` `int` `MAX = 100;` `// Function to find the maximum in column 'mid'``// 'rows' is number of rows.``int` `findMax(``int` `arr[][MAX], ``int` `rows, ``int` `mid, ``int``& max)``{``    ``int` `max_index = 0;``    ``for` `(``int` `i = 0; i < rows; i++) {``        ``if` `(max < arr[i][mid]) {``            ``// Saving global maximum and its index``            ``// to check its neighbours``            ``max = arr[i][mid];``            ``max_index = i;``        ``}``    ``}``    ``return` `max_index;``}` `// Function to find a peak element``int` `findPeakRec(``int` `arr[][MAX], ``int` `rows, ``int` `columns,``                ``int` `mid)``{``    ``// Evaluating maximum of mid column. Note max is``    ``// passed by reference.``    ``int` `max = 0;``    ``int` `max_index = findMax(arr, rows, mid, max);` `    ``// If we are on the first or last column,``    ``// max is a peak``    ``if` `(mid == 0 || mid == columns - 1)``        ``return` `max;` `    ``// If mid column maximum is also peak``    ``if` `(max >= arr[max_index][mid - 1] && max >= arr[max_index][mid + 1])``        ``return` `max;` `    ``// If max is less than its left``    ``if` `(max < arr[max_index][mid - 1])``        ``return` `findPeakRec(arr, rows, columns, mid - ``ceil``((``double``)mid / 2));` `    ``// If max is less than its left``    ``// if (max < arr[max_index][mid+1])``    ``return` `findPeakRec(arr, rows, columns, mid + ``ceil``((``double``)mid / 2));``}` `// A wrapper over findPeakRec()``int` `findPeak(``int` `arr[][MAX], ``int` `rows, ``int` `columns)``{``    ``return` `findPeakRec(arr, rows, columns, columns / 2);``}` `// Driver Code``int` `main()``{``    ``int` `arr[][MAX] = { { 10, 8, 10, 10 },``                       ``{ 14, 13, 12, 11 },``                       ``{ 15, 9, 11, 21 },``                       ``{ 16, 17, 19, 20 } };` `    ``// Number of Columns``    ``int` `rows = 4, columns = 4;``    ``cout << findPeak(arr, rows, columns);``    ``return` `0;``}`

## Java

 `// Finding peak element in a 2D Array.``class` `GFG``{``    ``static` `int` `MAX = ``100``;` `    ``// Function to find the maximum in column``    ``// 'mid', 'rows' is number of rows.``    ``static` `int` `findMax(``int``[][] arr, ``int` `rows,``                       ``int` `mid, ``int` `max)``    ``{``        ``int` `max_index = ``0``;``        ``for` `(``int` `i = ``0``; i < rows; i++)``        ``{``            ``if` `(max < arr[i][mid])``            ``{``                ` `                ``// Saving global maximum and its index``                ``// to check its neighbours``                ``max = arr[i][mid];``                ``max_index = i;``            ``}``        ``}``        ``return` `max_index;``    ``}` `    ``// Function to change the value of [max]``    ``static` `int` `Max(``int``[][] arr, ``int` `rows,``                   ``int` `mid, ``int` `max)``    ``{``        ``for` `(``int` `i = ``0``; i < rows; i++)``        ``{``            ``if` `(max < arr[i][mid])``            ``{``                ` `                ``// Saving global maximum and its index``                ``// to check its neighbours``                ``max = arr[i][mid];``            ``}``        ``}``        ``return` `max;``    ``}` `    ``// Function to find a peak element``    ``static` `int` `findPeakRec(``int``[][] arr, ``int` `rows,``                           ``int` `columns, ``int` `mid)``    ``{``        ``// Evaluating maximum of mid column.``        ``// Note max is passed by reference.``        ``int` `max = ``0``;``        ``int` `max_index = findMax(arr, rows, mid, max);``        ``max = Max(arr, rows, mid, max);` `        ``// If we are on the first or last column,``        ``// max is a peak``        ``if` `(mid == ``0` `|| mid == columns - ``1``)``            ``return` `max;` `        ``// If mid column maximum is also peak``        ``if` `(max >= arr[max_index][mid - ``1``] &&``            ``max >= arr[max_index][mid + ``1``])``            ``return` `max;` `        ``// If max is less than its left``        ``if` `(max < arr[max_index][mid - ``1``])``            ``return` `findPeakRec(arr, rows, columns,``                         ``(``int``)(mid - Math.ceil((``double``) mid / ``2``)));` `        ``// If max is less than its left``        ``// if (max < arr[max_index][mid+1])``        ``return` `findPeakRec(arr, rows, columns,``                     ``(``int``)(mid + Math.ceil((``double``) mid / ``2``)));``    ``}` `    ``// A wrapper over findPeakRec()``    ``static` `int` `findPeak(``int``[][] arr, ``int` `rows, ``int` `columns)``    ``{``        ``return` `findPeakRec(arr, rows, columns, columns / ``2``);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[][] arr = {{ ``10``, ``8``, ``10``, ``10` `},``                       ``{ ``14``, ``13``, ``12``, ``11` `},``                       ``{ ``15``, ``9``, ``11``, ``21` `},``                       ``{ ``16``, ``17``, ``19``, ``20` `}};``        ` `        ``// Number of Columns``        ``int` `rows = ``4``, columns = ``4``;``        ``System.out.println(findPeak(arr, rows, columns));``    ``}``}` `// This code is contributed by``// sanjeev2552`

## Python3

 `# Finding peak element in a 2D Array.``MAX` `=` `100``from` `math ``import` `ceil` `# Function to find the maximum in column 'mid'``# 'rows' is number of rows.``def` `findMax(arr, rows, mid,``max``):` `    ``max_index ``=` `0``    ``for` `i ``in` `range``(rows):``        ``if` `(``max` `< arr[i][mid]):``            ` `            ``# Saving global maximum and its index``            ``# to check its neighbours``            ``max` `=` `arr[i][mid]``            ``max_index ``=` `i``    ``#print(max_index)` `    ``return` `max``,max_index` `# Function to find a peak element``def` `findPeakRec(arr, rows, columns,mid):` `    ``# Evaluating maximum of mid column.``    ``# Note max is passed by reference.``    ``max` `=` `0``    ``max``, max_index ``=` `findMax(arr, rows, mid, ``max``)` `    ``# If we are on the first or last column,``    ``# max is a peak``    ``if` `(mid ``=``=` `0` `or` `mid ``=``=` `columns ``-` `1``):``        ``return` `max` `    ``# If mid column maximum is also peak``    ``if` `(``max` `>``=` `arr[max_index][mid ``-` `1``] ``and``        ``max` `>``=` `arr[max_index][mid ``+` `1``]):``        ``return` `max` `    ``# If max is less than its left``    ``if` `(``max` `< arr[max_index][mid ``-` `1``]):``        ``return` `findPeakRec(arr, rows, columns,``                           ``mid ``-` `ceil(mid ``/` `2.0``))` `    ``# If max is less than its left``    ``# if (max < arr[max_index][mid+1])``    ``return` `findPeakRec(arr, rows, columns,``                       ``mid ``+` `ceil(mid ``/` `2.0``))` `# A wrapper over findPeakRec()``def` `findPeak(arr, rows, columns):``    ``return` `findPeakRec(arr, rows,``                       ``columns, columns ``/``/` `2``)` `# Driver Code``arr ``=` `[ [ ``10``, ``8``, ``10``, ``10` `],``        ``[ ``14``, ``13``, ``12``, ``11` `],``        ``[ ``15``, ``9``, ``11``, ``21` `],``        ``[ ``16``, ``17``, ``19``, ``20` `] ]` `# Number of Columns``rows ``=` `4``columns ``=` `4``print``(findPeak(arr, rows, columns))` `# This code is contributed by Mohit Kumar`

## C#

 `// Finding peak element in a 2D Array.``using` `System;` `class` `GFG``{` `    ``// Function to find the maximum in column``    ``// 'mid', 'rows' is number of rows.``    ``static` `int` `findMax(``int``[,] arr, ``int` `rows,``                       ``int` `mid, ``int` `max)``    ``{``        ``int` `max_index = 0;``        ``for` `(``int` `i = 0; i < rows; i++)``        ``{``            ``if` `(max < arr[i,mid])``            ``{``                ` `                ``// Saving global maximum and its``                ``// index to check its neighbours``                ``max = arr[i,mid];``                ``max_index = i;``            ``}``        ``}``        ``return` `max_index;``    ``}` `    ``// Function to change the value of [max]``    ``static` `int` `Max(``int``[,] arr, ``int` `rows,``                   ``int` `mid, ``int` `max)``    ``{``        ``for` `(``int` `i = 0; i < rows; i++)``        ``{``            ``if` `(max < arr[i, mid])``            ``{``                ` `                ``// Saving global maximum and its``                ``// index to check its neighbours``                ``max = arr[i, mid];``            ``}``        ``}``        ``return` `max;``    ``}` `    ``// Function to find a peak element``    ``static` `int` `findPeakRec(``int``[,] arr, ``int` `rows,``                           ``int` `columns, ``int` `mid)``    ``{``        ``// Evaluating maximum of mid column.``        ``// Note max is passed by reference.``        ``int` `max = 0;``        ``int` `max_index = findMax(arr, rows, mid, max);``        ``max = Max(arr, rows, mid, max);` `        ``// If we are on the first or last column,``        ``// max is a peak``        ``if` `(mid == 0 || mid == columns - 1)``            ``return` `max;` `        ``// If mid column maximum is also peak``        ``if` `(max >= arr[max_index, mid - 1] &&``            ``max >= arr[max_index, mid + 1])``            ``return` `max;` `        ``// If max is less than its left``        ``if` `(max < arr[max_index,mid - 1])``            ``return` `findPeakRec(arr, rows, columns,``                   ``(``int``)(mid - Math.Ceiling((``double``) mid / 2)));` `        ``// If max is less than its left``        ``// if (max < arr[max_index][mid+1])``        ``return` `findPeakRec(arr, rows, columns,``               ``(``int``)(mid + Math.Ceiling((``double``) mid / 2)));``    ``}` `    ``// A wrapper over findPeakRec()``    ``static` `int` `findPeak(``int``[,] arr,``                        ``int` `rows, ``int` `columns)``    ``{``        ``return` `findPeakRec(arr, rows, columns,``                                      ``columns / 2);``    ``}` `    ``// Driver Code``    ``static` `public` `void` `Main ()``    ``{``        ``int``[,] arr = {{ 10, 8, 10, 10 },``                      ``{ 14, 13, 12, 11 },``                      ``{ 15, 9, 11, 21 },``                      ``{ 16, 17, 19, 20 }};``    ` `        ``// Number of Columns``        ``int` `rows = 4, columns = 4;``        ``Console.Write(findPeak(arr, rows, columns));``    ``}``}` `// This code is contributed by ajit.`

## Javascript

 ``

Output:

`21`

Time Complexity : O(rows * log(columns)). We recur for half the number of columns. In every recursive call, we linearly search for the maximum in the current mid column.
Auxiliary Space: O(columns/2) for Recursion Call Stack
Source:
https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-006-introduction-to-algorithms-fall-2011/lecture-videos/MIT6_006F11_lec01.pdf

This article is contributed by Rohit Thapliyal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.