# Print all the peaks and troughs in an Array of Integers

• Difficulty Level : Medium
• Last Updated : 12 May, 2021

Given an array of integers arr[], the task is to print a list of all the peaks and another list of all the troughs present in the array. A peak is an element in the array which is greater than its neighbouring elements. Similarly, a trough is an element that is smaller than its neighbouring elements.

Examples:

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.

Input: arr[] = {5, 10, 5, 7, 4, 3, 5}
Output:
Peaks : 10 7 5
Troughs : 5 5 3
Input: arr[] = {1, 2, 3, 4, 5}
Output:
Peaks : 5
Troughs : 1

Approach: For every element of the array, check whether the current element is a peak (the element has to be greater than its neighbouring elements) or a trough (the element has to be smaller than its neighbouring elements).
Note that the first and the last element of the array will have a single neighbour.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function that returns true if num is``// greater than both arr[i] and arr[j]``static` `bool` `isPeak(``int` `arr[], ``int` `n, ``int` `num,``                   ``int` `i, ``int` `j)``{` `    ``// If num is smaller than the element``    ``// on the left (if exists)``    ``if` `(i >= 0 && arr[i] > num)``        ``return` `false``;` `    ``// If num is smaller than the element``    ``// on the right (if exists)``    ``if` `(j < n && arr[j] > num)``        ``return` `false``;``    ``return` `true``;``}` `// Function that returns true if num is``// smaller than both arr[i] and arr[j]``static` `bool` `isTrough(``int` `arr[], ``int` `n, ``int` `num,``                     ``int` `i, ``int` `j)``{` `    ``// If num is greater than the element``    ``// on the left (if exists)``    ``if` `(i >= 0 && arr[i] < num)``        ``return` `false``;` `    ``// If num is greater than the element``    ``// on the right (if exists)``    ``if` `(j < n && arr[j] < num)``        ``return` `false``;``    ``return` `true``;``}` `void` `printPeaksTroughs(``int` `arr[], ``int` `n)``{``    ``cout << ``"Peaks : "``;` `    ``// For every element``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If the current element is a peak``        ``if` `(isPeak(arr, n, arr[i], i - 1, i + 1))``            ``cout << arr[i] << ``" "``;``    ``}``    ``cout << endl;` `    ``cout << ``"Troughs : "``;` `    ``// For every element``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If the current element is a trough``        ``if` `(isTrough(arr, n, arr[i], i - 1, i + 1))``            ``cout << arr[i] << ``" "``;``    ``}``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 5, 10, 5, 7, 4, 3, 5 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``printPeaksTroughs(arr, n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG``{` `    ``// Function that returns true if num is``    ``// greater than both arr[i] and arr[j]``    ``static` `boolean` `isPeak(``int` `arr[], ``int` `n, ``int` `num,``                                    ``int` `i, ``int` `j)``    ``{` `        ``// If num is smaller than the element``        ``// on the left (if exists)``        ``if` `(i >= ``0` `&& arr[i] > num)``        ``{``            ``return` `false``;``        ``}` `        ``// If num is smaller than the element``        ``// on the right (if exists)``        ``if` `(j < n && arr[j] > num)``        ``{``            ``return` `false``;``        ``}``        ``return` `true``;``    ``}` `    ``// Function that returns true if num is``    ``// smaller than both arr[i] and arr[j]``    ``static` `boolean` `isTrough(``int` `arr[], ``int` `n, ``int` `num,``                                        ``int` `i, ``int` `j)``    ``{` `        ``// If num is greater than the element``        ``// on the left (if exists)``        ``if` `(i >= ``0` `&& arr[i] < num)``        ``{``            ``return` `false``;``        ``}` `        ``// If num is greater than the element``        ``// on the right (if exists)``        ``if` `(j < n && arr[j] < num)``        ``{``            ``return` `false``;``        ``}``        ``return` `true``;``    ``}` `    ``static` `void` `printPeaksTroughs(``int` `arr[], ``int` `n)``    ``{``        ``System.out.print(``"Peaks : "``);` `        ``// For every element``        ``for` `(``int` `i = ``0``; i < n; i++)``        ``{` `            ``// If the current element is a peak``            ``if` `(isPeak(arr, n, arr[i], i - ``1``, i + ``1``))``            ``{``                ``System.out.print(arr[i] + ``" "``);``            ``}``        ``}``        ``System.out.println(``""``);` `        ``System.out.print(``"Troughs : "``);` `        ``// For every element``        ``for` `(``int` `i = ``0``; i < n; i++)``        ``{` `            ``// If the current element is a trough``            ``if` `(isTrough(arr, n, arr[i], i - ``1``, i + ``1``))``            ``{``                ``System.out.print(arr[i] + ``" "``);``            ``}``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = {``5``, ``10``, ``5``, ``7``, ``4``, ``3``, ``5``};``        ``int` `n = arr.length;` `        ``printPeaksTroughs(arr, n);``    ``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 implementation of the approach` `# Function that returns true if num is``# greater than both arr[i] and arr[j]``def` `isPeak(arr, n, num, i, j):` `    ``# If num is smaller than the element``    ``# on the left (if exists)``    ``if` `(i >``=` `0` `and` `arr[i] > num):``        ``return` `False` `    ``# If num is smaller than the element``    ``# on the right (if exists)``    ``if` `(j < n ``and` `arr[j] > num):``        ``return` `False``    ``return` `True` `# Function that returns true if num is``# smaller than both arr[i] and arr[j]``def` `isTrough(arr, n, num, i, j):` `    ``# If num is greater than the element``    ``# on the left (if exists)``    ``if` `(i >``=` `0` `and` `arr[i] < num):``        ``return` `False` `    ``# If num is greater than the element``    ``# on the right (if exists)``    ``if` `(j < n ``and` `arr[j] < num):``        ``return` `False``    ``return` `True` `def` `printPeaksTroughs(arr, n):` `    ``print``(``"Peaks : "``, end ``=` `"")` `    ``# For every element``    ``for` `i ``in` `range``(n):` `        ``# If the current element is a peak``        ``if` `(isPeak(arr, n, arr[i], i ``-` `1``, i ``+` `1``)):``            ``print``(arr[i], end ``=` `" "``)``    ``print``()` `    ``print``(``"Troughs : "``, end ``=` `"")` `    ``# For every element``    ``for` `i ``in` `range``(n):` `        ``# If the current element is a trough``        ``if` `(isTrough(arr, n, arr[i], i ``-` `1``, i ``+` `1``)):``            ``print``(arr[i], end ``=` `" "``)` `# Driver code``arr ``=` `[``5``, ``10``, ``5``, ``7``, ``4``, ``3``, ``5``]``n ``=` `len``(arr)` `printPeaksTroughs(arr, n)` `# This code is contributed by Mohit Kumar`

## C#

 `// C# implementation of the approach``using` `System;``    ` `class` `GFG``{` `    ``// Function that returns true if num is``    ``// greater than both arr[i] and arr[j]``    ``static` `Boolean isPeak(``int` `[]arr, ``int` `n, ``int` `num,``                                    ``int` `i, ``int` `j)``    ``{` `        ``// If num is smaller than the element``        ``// on the left (if exists)``        ``if` `(i >= 0 && arr[i] > num)``        ``{``            ``return` `false``;``        ``}` `        ``// If num is smaller than the element``        ``// on the right (if exists)``        ``if` `(j < n && arr[j] > num)``        ``{``            ``return` `false``;``        ``}``        ``return` `true``;``    ``}` `    ``// Function that returns true if num is``    ``// smaller than both arr[i] and arr[j]``    ``static` `Boolean isTrough(``int` `[]arr, ``int` `n, ``int` `num,``                                        ``int` `i, ``int` `j)``    ``{` `        ``// If num is greater than the element``        ``// on the left (if exists)``        ``if` `(i >= 0 && arr[i] < num)``        ``{``            ``return` `false``;``        ``}` `        ``// If num is greater than the element``        ``// on the right (if exists)``        ``if` `(j < n && arr[j] < num)``        ``{``            ``return` `false``;``        ``}``        ``return` `true``;``    ``}` `    ``static` `void` `printPeaksTroughs(``int` `[]arr, ``int` `n)``    ``{``        ``Console.Write(``"Peaks : "``);` `        ``// For every element``        ``for` `(``int` `i = 0; i < n; i++)``        ``{` `            ``// If the current element is a peak``            ``if` `(isPeak(arr, n, arr[i], i - 1, i + 1))``            ``{``                ``Console.Write(arr[i] + ``" "``);``            ``}``        ``}``        ``Console.WriteLine(``""``);` `        ``Console.Write(``"Troughs : "``);` `        ``// For every element``        ``for` `(``int` `i = 0; i < n; i++)``        ``{` `            ``// If the current element is a trough``            ``if` `(isTrough(arr, n, arr[i], i - 1, i + 1))``            ``{``                ``Console.Write(arr[i] + ``" "``);``            ``}``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int` `[]arr = {5, 10, 5, 7, 4, 3, 5};``        ``int` `n = arr.Length;` `        ``printPeaksTroughs(arr, n);``    ``}``}` `// This code is contributed by Princi Singh`

## Javascript

 ``
Output:
```Peaks : 10 7 5
Troughs : 5 5 3```

My Personal Notes arrow_drop_up