# Find the minimum element in a sorted and rotated array

A sorted array is rotated at some unknown point, find the minimum element in it.

Following solution assumes that all elements are distinct.

Examples:

```Input: {5, 6, 1, 2, 3, 4}
Output: 1

Input: {1, 2, 3, 4}
Output: 1

Input: {2, 1}
Output: 1```

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

A simple solution is to traverse the complete array and find minimum. This solution requires O(n) time.
We can do it in O(Logn) using Binary Search. If we take a closer look at above examples, we can easily figure out following pattern:

• The minimum element is the only element whose previous is greater than it. If there is no previous element element, then there is no rotation (first element is minimum). We check this condition for middle element by comparing it with (mid-1)’th and (mid+1)’th elements.
• If minimum element is not at middle (neither mid nor mid + 1), then minimum element lies in either left half or right half.
1. If middle element is smaller than last element, then the minimum element lies in left half
2. Else minimum element lies in right half.

We strongly recommend you to try it yourself before seeing the following implementation.

## C++

 `// C++ program to find minimum  ` `// element in a sorted and rotated array  ` `#include ` `using` `namespace` `std; ` ` `  `int` `findMin(``int` `arr[], ``int` `low, ``int` `high)  ` `{  ` `    ``// This condition is needed to  ` `    ``// handle the case when array is not  ` `    ``// rotated at all  ` `    ``if` `(high < low) ``return` `arr;  ` ` `  `    ``// If there is only one element left  ` `    ``if` `(high == low) ``return` `arr[low];  ` ` `  `    ``// Find mid  ` `    ``int` `mid = low + (high - low)/2; ``/*(low + high)/2;*/` ` `  `    ``// Check if element (mid+1) is minimum element. Consider  ` `    ``// the cases like {3, 4, 5, 1, 2}  ` `    ``if` `(mid < high && arr[mid + 1] < arr[mid])  ` `    ``return` `arr[mid + 1];  ` ` `  `    ``// Check if mid itself is minimum element  ` `    ``if` `(mid > low && arr[mid] < arr[mid - 1])  ` `    ``return` `arr[mid];  ` ` `  `    ``// Decide whether we need to go to left half or right half  ` `    ``if` `(arr[high] > arr[mid])  ` `    ``return` `findMin(arr, low, mid - 1);  ` `    ``return` `findMin(arr, mid + 1, high);  ` `}  ` ` `  `// Driver program to test above functions  ` `int` `main()  ` `{  ` `    ``int` `arr1[] = {5, 6, 1, 2, 3, 4};  ` `    ``int` `n1 = ``sizeof``(arr1)/``sizeof``(arr1);  ` `    ``cout << ``"The minimum element is "` `<< findMin(arr1, 0, n1-1) << endl;  ` ` `  `    ``int` `arr2[] = {1, 2, 3, 4};  ` `    ``int` `n2 = ``sizeof``(arr2)/``sizeof``(arr2);  ` `    ``cout << ``"The minimum element is "` `<< findMin(arr2, 0, n2-1) << endl;  ` ` `  `    ``int` `arr3[] = {1};  ` `    ``int` `n3 = ``sizeof``(arr3)/``sizeof``(arr3);  ` `    ``cout<<``"The minimum element is "``<

## C

 `// C program to find minimum element in a sorted and rotated array ` `#include ` ` `  `int` `findMin(``int` `arr[], ``int` `low, ``int` `high) ` `{ ` `    ``// This condition is needed to handle the case when array is not ` `    ``// rotated at all ` `    ``if` `(high < low)  ``return` `arr; ` ` `  `    ``// If there is only one element left ` `    ``if` `(high == low) ``return` `arr[low]; ` ` `  `    ``// Find mid ` `    ``int` `mid = low + (high - low)/2; ``/*(low + high)/2;*/` ` `  `    ``// Check if element (mid+1) is minimum element. Consider ` `    ``// the cases like {3, 4, 5, 1, 2} ` `    ``if` `(mid < high && arr[mid+1] < arr[mid]) ` `       ``return` `arr[mid+1]; ` ` `  `    ``// Check if mid itself is minimum element ` `    ``if` `(mid > low && arr[mid] < arr[mid - 1]) ` `       ``return` `arr[mid]; ` ` `  `    ``// Decide whether we need to go to left half or right half ` `    ``if` `(arr[high] > arr[mid]) ` `       ``return` `findMin(arr, low, mid-1); ` `    ``return` `findMin(arr, mid+1, high); ` `} ` ` `  `// Driver program to test above functions ` `int` `main() ` `{ ` `    ``int` `arr1[] =  {5, 6, 1, 2, 3, 4}; ` `    ``int` `n1 = ``sizeof``(arr1)/``sizeof``(arr1); ` `    ``printf``(``"The minimum element is %d\n"``, findMin(arr1, 0, n1-1)); ` ` `  `    ``int` `arr2[] =  {1, 2, 3, 4}; ` `    ``int` `n2 = ``sizeof``(arr2)/``sizeof``(arr2); ` `    ``printf``(``"The minimum element is %d\n"``, findMin(arr2, 0, n2-1)); ` ` `  `    ``int` `arr3[] =  {1}; ` `    ``int` `n3 = ``sizeof``(arr3)/``sizeof``(arr3); ` `    ``printf``(``"The minimum element is %d\n"``, findMin(arr3, 0, n3-1)); ` ` `  `    ``int` `arr4[] =  {1, 2}; ` `    ``int` `n4 = ``sizeof``(arr4)/``sizeof``(arr4); ` `    ``printf``(``"The minimum element is %d\n"``, findMin(arr4, 0, n4-1)); ` ` `  `    ``int` `arr5[] =  {2, 1}; ` `    ``int` `n5 = ``sizeof``(arr5)/``sizeof``(arr5); ` `    ``printf``(``"The minimum element is %d\n"``, findMin(arr5, 0, n5-1)); ` ` `  `    ``int` `arr6[] =  {5, 6, 7, 1, 2, 3, 4}; ` `    ``int` `n6 = ``sizeof``(arr6)/``sizeof``(arr6); ` `    ``printf``(``"The minimum element is %d\n"``, findMin(arr6, 0, n6-1)); ` ` `  `    ``int` `arr7[] =  {1, 2, 3, 4, 5, 6, 7}; ` `    ``int` `n7 = ``sizeof``(arr7)/``sizeof``(arr7); ` `    ``printf``(``"The minimum element is %d\n"``, findMin(arr7, 0, n7-1)); ` ` `  `    ``int` `arr8[] =  {2, 3, 4, 5, 6, 7, 8, 1}; ` `    ``int` `n8 = ``sizeof``(arr8)/``sizeof``(arr8); ` `    ``printf``(``"The minimum element is %d\n"``, findMin(arr8, 0, n8-1)); ` ` `  `    ``int` `arr9[] =  {3, 4, 5, 1, 2}; ` `    ``int` `n9 = ``sizeof``(arr9)/``sizeof``(arr9); ` `    ``printf``(``"The minimum element is %d\n"``, findMin(arr9, 0, n9-1)); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to find minimum element in a sorted and rotated array ` `import` `java.util.*; ` `import` `java.lang.*; ` `import` `java.io.*; ` ` `  `class` `Minimum ` `{ ` `    ``static` `int` `findMin(``int` `arr[], ``int` `low, ``int` `high) ` `    ``{ ` `        ``// This condition is needed to handle the case when array ` `        ``// is not rotated at all ` `        ``if` `(high < low)  ``return` `arr[``0``]; ` ` `  `        ``// If there is only one element left ` `        ``if` `(high == low) ``return` `arr[low]; ` ` `  `        ``// Find mid ` `        ``int` `mid = low + (high - low)/``2``; ``/*(low + high)/2;*/` ` `  `        ``// Check if element (mid+1) is minimum element. Consider ` `        ``// the cases like {3, 4, 5, 1, 2} ` `        ``if` `(mid < high && arr[mid+``1``] < arr[mid]) ` `            ``return` `arr[mid+``1``]; ` ` `  `        ``// Check if mid itself is minimum element ` `        ``if` `(mid > low && arr[mid] < arr[mid - ``1``]) ` `            ``return` `arr[mid]; ` ` `  `        ``// Decide whether we need to go to left half or right half ` `        ``if` `(arr[high] > arr[mid]) ` `            ``return` `findMin(arr, low, mid-``1``); ` `        ``return` `findMin(arr, mid+``1``, high); ` `    ``} ` ` `  `    ``// Driver Program ` `    ``public` `static` `void` `main (String[] args) ` `    ``{ ` `        ``int` `arr1[] =  {``5``, ``6``, ``1``, ``2``, ``3``, ``4``}; ` `        ``int` `n1 = arr1.length; ` `        ``System.out.println(``"The minimum element is "``+ findMin(arr1, ``0``, n1-``1``)); ` ` `  `        ``int` `arr2[] =  {``1``, ``2``, ``3``, ``4``}; ` `        ``int` `n2 = arr2.length; ` `        ``System.out.println(``"The minimum element is "``+ findMin(arr2, ``0``, n2-``1``)); ` ` `  `        ``int` `arr3[] =  {``1``}; ` `        ``int` `n3 = arr3.length; ` `        ``System.out.println(``"The minimum element is "``+ findMin(arr3, ``0``, n3-``1``)); ` ` `  `        ``int` `arr4[] =  {``1``, ``2``}; ` `        ``int` `n4 = arr4.length; ` `        ``System.out.println(``"The minimum element is "``+ findMin(arr4, ``0``, n4-``1``)); ` ` `  `        ``int` `arr5[] =  {``2``, ``1``}; ` `        ``int` `n5 = arr5.length; ` `        ``System.out.println(``"The minimum element is "``+ findMin(arr5, ``0``, n5-``1``)); ` ` `  `        ``int` `arr6[] =  {``5``, ``6``, ``7``, ``1``, ``2``, ``3``, ``4``}; ` `        ``int` `n6 = arr6.length; ` `        ``System.out.println(``"The minimum element is "``+ findMin(arr6, ``0``, n6-``1``)); ` ` `  `        ``int` `arr7[] =  {``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``}; ` `        ``int` `n7 = arr7.length; ` `        ``System.out.println(``"The minimum element is "``+ findMin(arr7, ``0``, n7-``1``)); ` ` `  `        ``int` `arr8[] =  {``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``, ``1``}; ` `        ``int` `n8 = arr8.length; ` `        ``System.out.println(``"The minimum element is "``+ findMin(arr8, ``0``, n8-``1``)); ` ` `  `        ``int` `arr9[] =  {``3``, ``4``, ``5``, ``1``, ``2``}; ` `        ``int` `n9 = arr9.length; ` `        ``System.out.println(``"The minimum element is "``+ findMin(arr9, ``0``, n9-``1``)); ` `    ``} ` `} `

## Python

 `# Python program to find minimum element ` `# in a sorted and rotated array ` ` `  `def` `findMin(arr, low, high): ` `    ``# This condition is needed to handle the case when array is not ` `    ``# rotated at all ` `    ``if` `high < low: ` `        ``return` `arr[``0``] ` ` `  `    ``# If there is only one element left ` `    ``if` `high ``=``=` `low: ` `        ``return` `arr[low] ` ` `  `    ``# Find mid ` `    ``mid ``=` `int``((low ``+` `high)``/``2``) ` ` `  `    ``# Check if element (mid+1) is minimum element. Consider ` `    ``# the cases like [3, 4, 5, 1, 2] ` `    ``if` `mid < high ``and` `arr[mid``+``1``] < arr[mid]: ` `        ``return` `arr[mid``+``1``] ` ` `  `    ``# Check if mid itself is minimum element ` `    ``if` `mid > low ``and` `arr[mid] < arr[mid ``-` `1``]: ` `        ``return` `arr[mid] ` ` `  `    ``# Decide whether we need to go to left half or right half ` `    ``if` `arr[high] > arr[mid]: ` `        ``return` `findMin(arr, low, mid``-``1``) ` `    ``return` `findMin(arr, mid``+``1``, high) ` ` `  `# Driver program to test above functions ` `arr1 ``=` `[``5``, ``6``, ``1``, ``2``, ``3``, ``4``] ` `n1 ``=` `len``(arr1) ` `print``(``"The minimum element is "` `+` `str``(findMin(arr1, ``0``, n1``-``1``))) ` ` `  `arr2 ``=` `[``1``, ``2``, ``3``, ``4``] ` `n2 ``=` `len``(arr2) ` `print``(``"The minimum element is "` `+` `str``(findMin(arr2, ``0``, n2``-``1``))) ` ` `  `arr3 ``=` `[``1``] ` `n3 ``=` `len``(arr3) ` `print``(``"The minimum element is "` `+` `str``(findMin(arr3, ``0``, n3``-``1``))) ` ` `  `arr4 ``=` `[``1``, ``2``] ` `n4 ``=` `len``(arr4) ` `print``(``"The minimum element is "` `+` `str``(findMin(arr4, ``0``, n4``-``1``))) ` ` `  `arr5 ``=` `[``2``, ``1``] ` `n5 ``=` `len``(arr5) ` `print``(``"The minimum element is "` `+` `str``(findMin(arr5, ``0``, n5``-``1``))) ` ` `  `arr6 ``=` `[``5``, ``6``, ``7``, ``1``, ``2``, ``3``, ``4``] ` `n6 ``=` `len``(arr6) ` `print``(``"The minimum element is "` `+` `str``(findMin(arr6, ``0``, n6``-``1``))) ` ` `  `arr7 ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7``] ` `n7 ``=` `len``(arr7) ` `print``(``"The minimum element is "` `+` `str``(findMin(arr7, ``0``, n7``-``1``))) ` ` `  `arr8 ``=` `[``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``, ``1``] ` `n8 ``=` `len``(arr8) ` `print``(``"The minimum element is "` `+` `str``(findMin(arr8, ``0``, n8``-``1``))) ` ` `  `arr9 ``=` `[``3``, ``4``, ``5``, ``1``, ``2``] ` `n9 ``=` `len``(arr9) ` `print``(``"The minimum element is "` `+` `str``(findMin(arr9, ``0``, n9``-``1``))) ` ` `  `# This code is contributed by Pratik Chhajer `

## C#

 `// C# program to find minimum element  ` `// in a sorted and rotated array ` `using` `System; ` ` `  `class` `Minimum { ` ` `  `    ``static` `int` `findMin(``int``[] arr, ``int` `low, ``int` `high) ` `    ``{ ` `        ``// This condition is needed to handle  ` `        ``// the case when array ` `        ``// is not rotated at all ` `        ``if` `(high < low) ` `            ``return` `arr; ` ` `  `        ``// If there is only one element left ` `        ``if` `(high == low) ` `            ``return` `arr[low]; ` ` `  `        ``// Find mid ` `        ``// (low + high)/2 ` `        ``int` `mid = low + (high - low) / 2;  ` ` `  `        ``// Check if element (mid+1) is minimum element. Consider ` `        ``// the cases like {3, 4, 5, 1, 2} ` `        ``if` `(mid < high && arr[mid + 1] < arr[mid]) ` `            ``return` `arr[mid + 1]; ` ` `  `        ``// Check if mid itself is minimum element ` `        ``if` `(mid > low && arr[mid] < arr[mid - 1]) ` `            ``return` `arr[mid]; ` ` `  `        ``// Decide whether we need to go to ` `        ``// left half or right half ` `        ``if` `(arr[high] > arr[mid]) ` `            ``return` `findMin(arr, low, mid - 1); ` `        ``return` `findMin(arr, mid + 1, high); ` `    ``} ` ` `  `    ``// Driver Program ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int``[] arr1 = { 5, 6, 1, 2, 3, 4 }; ` `        ``int` `n1 = arr1.Length; ` `        ``Console.WriteLine(``"The minimum element is "` `+  ` `                           ``findMin(arr1, 0, n1 - 1)); ` ` `  `        ``int``[] arr2 = { 1, 2, 3, 4 }; ` `        ``int` `n2 = arr2.Length; ` `        ``Console.WriteLine(``"The minimum element is "` `+  ` `                           ``findMin(arr2, 0, n2 - 1)); ` ` `  `        ``int``[] arr3 = { 1 }; ` `        ``int` `n3 = arr3.Length; ` `        ``Console.WriteLine(``"The minimum element is "` `+  ` `                           ``findMin(arr3, 0, n3 - 1)); ` ` `  `        ``int``[] arr4 = { 1, 2 }; ` `        ``int` `n4 = arr4.Length; ` `        ``Console.WriteLine(``"The minimum element is "` `+  ` `                           ``findMin(arr4, 0, n4 - 1)); ` ` `  `        ``int``[] arr5 = { 2, 1 }; ` `        ``int` `n5 = arr5.Length; ` `        ``Console.WriteLine(``"The minimum element is "` `+  ` `                           ``findMin(arr5, 0, n5 - 1)); ` ` `  `        ``int``[] arr6 = { 5, 6, 7, 1, 2, 3, 4 }; ` `        ``int` `n6 = arr6.Length; ` `        ``Console.WriteLine(``"The minimum element is "` `+  ` `                           ``findMin(arr6, 0, n1 - 1)); ` ` `  `        ``int``[] arr7 = { 1, 2, 3, 4, 5, 6, 7 }; ` `        ``int` `n7 = arr7.Length; ` `        ``Console.WriteLine(``"The minimum element is "` `+ ` `                           ``findMin(arr7, 0, n7 - 1)); ` ` `  `        ``int``[] arr8 = { 2, 3, 4, 5, 6, 7, 8, 1 }; ` `        ``int` `n8 = arr8.Length; ` `        ``Console.WriteLine(``"The minimum element is "` `+  ` `                           ``findMin(arr8, 0, n8 - 1)); ` ` `  `        ``int``[] arr9 = { 3, 4, 5, 1, 2 }; ` `        ``int` `n9 = arr9.Length; ` `        ``Console.WriteLine(``"The minimum element is "` `+  ` `                           ``findMin(arr9, 0, n9 - 1)); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m. `

## PHP

 ` ``\$low` `&&  ` `        ``\$arr``[``\$mid``] < ``\$arr``[``\$mid` `- 1]) ` `    ``return` `\$arr``[``\$mid``]; ` ` `  `    ``// Decide whether we need  ` `    ``// to go to left half or  ` `    ``// right half ` `    ``if` `(``\$arr``[``\$high``] > ``\$arr``[``\$mid``]) ` `    ``return` `findMin(``\$arr``, ``\$low``,  ` `                   ``\$mid` `- 1); ` `    ``return` `findMin(``\$arr``,  ` `                   ``\$mid` `+ 1, ``\$high``); ` `} ` ` `  `// Driver Code ` `\$arr1` `= ``array``(5, 6, 1, 2, 3, 4); ` `\$n1` `= sizeof(``\$arr1``); ` `echo` `"The minimum element is "` `.  ` `    ``findMin(``\$arr1``, 0, ``\$n1` `- 1) . ``"\n"``; ` ` `  `\$arr2` `= ``array``(1, 2, 3, 4); ` `\$n2` `= sizeof(``\$arr2``); ` `echo` `"The minimum element is "` `.  ` `    ``findMin(``\$arr2``, 0, ``\$n2` `- 1) . ``"\n"``; ` ` `  `\$arr3` `= ``array``(1); ` `\$n3` `= sizeof(``\$arr3``); ` `echo` `"The minimum element is "` `.  ` `    ``findMin(``\$arr3``, 0, ``\$n3` `- 1) . ``"\n"``; ` ` `  `\$arr4` `= ``array``(1, 2); ` `\$n4` `= sizeof(``\$arr4``); ` `echo` `"The minimum element is "` `.  ` `    ``findMin(``\$arr4``, 0, ``\$n4` `- 1) . ``"\n"``; ` ` `  `\$arr5` `= ``array``(2, 1); ` `\$n5` `= sizeof(``\$arr5``); ` `echo` `"The minimum element is "` `.  ` `    ``findMin(``\$arr5``, 0, ``\$n5` `- 1) . ``"\n"``; ` ` `  `\$arr6` `= ``array``(5, 6, 7, 1, 2, 3, 4); ` `\$n6` `= sizeof(``\$arr6``); ` `echo` `"The minimum element is "` `.  ` `    ``findMin(``\$arr6``, 0, ``\$n6` `- 1) . ``"\n"``; ` ` `  `\$arr7` `= ``array``(1, 2, 3, 4, 5, 6, 7); ` `\$n7` `= sizeof(``\$arr7``); ` `echo` `"The minimum element is "` `.  ` `    ``findMin(``\$arr7``, 0, ``\$n7` `- 1) . ``"\n"``; ` ` `  `\$arr8` `= ``array``(2, 3, 4, 5, 6, 7, 8, 1); ` `\$n8` `= sizeof(``\$arr8``); ` `echo` `"The minimum element is "` `.  ` `    ``findMin(``\$arr8``, 0, ``\$n8` `- 1) . ``"\n"``; ` ` `  `\$arr9` `= ``array``(3, 4, 5, 1, 2); ` `\$n9` `= sizeof(``\$arr9``); ` `echo` `"The minimum element is "` `. ` `    ``findMin(``\$arr9``, 0, ``\$n9` `- 1) . ``"\n"``; ` ` `  `// This code is contributed by ChitraNayal ` `?> `

Output:

```The minimum element is 1
The minimum element is 1
The minimum element is 1
The minimum element is 1
The minimum element is 1
The minimum element is 1
The minimum element is 1
The minimum element is 1
The minimum element is 1```

How to handle duplicates?
Above approach in the worst case(If all the elements are same) take O(N).

Below is the code to handle duplicates in O(log n) time.

## C++

 `// C++ program to find minimum element in a sorted  ` `// and rotated array contating duplicate elements. ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find minimum element  ` `int` `findMin(``int` `arr[], ``int` `low, ``int` `high)  ` `{  ` `    ``while``(low < high) ` `    ``{ ` `        ``int` `mid = low + (high - low)/2; ` `        ``if` `(arr[mid] == arr[high]) ` `            ``high--; ` `        ``else` `if``(arr[mid] > arr[high]) ` `            ``low = mid + 1; ` `        ``else` `            ``high = mid; ` `    ``} ` `    ``return` `arr[high]; ` `}  ` ` `  `// Driver code ` `int` `main()  ` `{  ` `    ``int` `arr1[] = {5, 6, 1, 2, 3, 4};  ` `    ``int` `n1 = ``sizeof``(arr1)/``sizeof``(arr1);  ` `    ``cout << ``"The minimum element is "` `<< findMin(arr1, 0, n1-1) << endl;  ` `  `  `    ``int` `arr2[] = {1, 2, 3, 4};  ` `    ``int` `n2 = ``sizeof``(arr2)/``sizeof``(arr2);  ` `    ``cout << ``"The minimum element is "` `<< findMin(arr2, 0, n2-1) << endl;  ` `  `  `    ``int` `arr3[] = {1};  ` `    ``int` `n3 = ``sizeof``(arr3)/``sizeof``(arr3);  ` `    ``cout<<``"The minimum element is "``<

## Java

 `// Java program to find minimum element ` `// in a sorted and rotated array contating ` `// duplicate elements. ` `import` `java.util.*;  ` `import` `java.lang.*;  ` ` `  `class` `GFG{ ` `     `  `// Function to find minimum element  ` `public` `static` `int` `findMin(``int` `arr[],  ` `                          ``int` `low, ``int` `high)  ` `{  ` `    ``while``(low < high) ` `    ``{ ` `        ``int` `mid = low + (high - low) / ``2``; ` `        ``if` `(arr[mid] == arr[high]) ` `            ``high--; ` `             `  `        ``else` `if``(arr[mid] > arr[high]) ` `            ``low = mid + ``1``; ` `        ``else` `            ``high = mid; ` `    ``} ` `    ``return` `arr[high]; ` `}  ` ` `  `// Driver code ` `public` `static` `void` `main(String args[])  ` `{  ` `    ``int` `arr1[] = { ``5``, ``6``, ``1``, ``2``, ``3``, ``4` `};  ` `    ``int` `n1 = arr1.length;  ` `    ``System.out.println(``"The minimum element is "` `+  ` `                       ``findMin(arr1, ``0``, n1 - ``1``));  ` ` `  `    ``int` `arr2[] = { ``1``, ``2``, ``3``, ``4` `};  ` `    ``int` `n2 = arr2.length;  ` `    ``System.out.println(``"The minimum element is "` `+  ` `                       ``findMin(arr2, ``0``, n2 - ``1``));  ` ` `  `    ``int` `arr3[] = {``1``};  ` `    ``int` `n3 = arr3.length;  ` `    ``System.out.println(``"The minimum element is "` `+  ` `                       ``findMin(arr3, ``0``, n3 - ``1``));  ` ` `  `    ``int` `arr4[] = { ``1``, ``2` `};  ` `    ``int` `n4 = arr4.length;  ` `    ``System.out.println(``"The minimum element is "` `+  ` `                       ``findMin(arr4, ``0``, n4 - ``1``));  ` ` `  `    ``int` `arr5[] = { ``2``, ``1` `};  ` `    ``int` `n5 = arr5.length;  ` `    ``System.out.println(``"The minimum element is "` `+  ` `                       ``findMin(arr5, ``0``, n5 - ``1``));  ` ` `  `    ``int` `arr6[] = { ``5``, ``6``, ``7``, ``1``, ``2``, ``3``, ``4` `};  ` `    ``int` `n6 = arr6.length;  ` `    ``System.out.println(``"The minimum element is "` `+  ` `                       ``findMin(arr6, ``0``, n6 - ``1``));  ` ` `  `    ``int` `arr7[] = { ``1``, ``2``, ``3``, ``4``, ``5``, ``6``, ``7` `};  ` `    ``int` `n7 = arr7.length;  ` `    ``System.out.println(``"The minimum element is "` `+  ` `                       ``findMin(arr7, ``0``, n7 - ``1``));  ` ` `  `    ``int` `arr8[] = { ``2``, ``3``, ``4``, ``5``, ``6``, ``7``, ``8``, ``1` `};  ` `    ``int` `n8 = arr8.length;  ` `    ``System.out.println(``"The minimum element is "` `+ ` `                       ``findMin(arr8, ``0``, n8 - ``1``));  ` ` `  `    ``int` `arr9[] = { ``3``, ``4``, ``5``, ``1``, ``2` `};  ` `    ``int` `n9 = arr9.length;  ` `    ``System.out.println(``"The minimum element is "` `+  ` `                       ``findMin(arr9, ``0``, n9 - ``1``));  ` `} ` `} ` ` `  `// This is code is contributed by SoumikMondal `

Output:

```The minimum element is 1
The minimum element is 1
The minimum element is 1
The minimum element is 1
The minimum element is 1
The minimum element is 1
The minimum element is 1
The minimum element is 1
The minimum element is 1
```

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.

My Personal Notes arrow_drop_up

Article Tags :

44

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.