 Open in App
Not now

# Find bitonic point in given bitonic sequence

• Difficulty Level : Easy
• Last Updated : 06 Dec, 2022

You are given a bitonic sequence, the task is to find Bitonic Point in it. A Bitonic Sequence is a sequence of numbers which is first strictly increasing then after a point strictly decreasing.
A Bitonic Point is a point in bitonic sequence before which elements are strictly increasing and after which elements are strictly decreasing. A Bitonic point doesn’t exist if array is only decreasing or only increasing.

Examples :

```Input : arr[] = {6, 7, 8, 11, 9, 5, 2, 1}
Output: 11
All elements before 11 are smaller and all
elements after 11 are greater.

Input : arr[] = {-3, -2, 4, 6, 10, 8, 7, 1}
Output: 10```

Approach 1 : (Recursive Solution)

A simple solution for this problem is to use linear search. Element arr[i] is bitonic point if both i-1’th and i+1’th both elements are less than i’th element. Time complexity for this approach is O(n).

An efficient solution for this problem is to use modified binary search
If arr[mid-1] < arr[mid] and arr[mid] > arr[mid+1] then we are done with bitonic point.

• If arr[mid] < arr[mid+1] then search in right sub-array, else search in left sub-array.

Implementation:

## C++

 `// C++ program to find bitonic point in a bitonic array.``#include``using` `namespace` `std;` `// Function to find bitonic point using binary search``int` `binarySearch(``int` `arr[], ``int` `left, ``int` `right)``{``    ``if` `(left <= right)``    ``{``        ``int` `mid = (left+right)/2;` `        ``// base condition to check if arr[mid] is``        ``// bitonic point or not``        ``if` `(arr[mid-1]arr[mid+1])``            ``return` `mid;` `        ``// We assume that sequence is bitonic. We go to``        ``// right subarray if middle point is part of``        ``// increasing subsequence. Else we go to left``        ``// subarray.``        ``if` `(arr[mid] < arr[mid+1])``            ``return` `binarySearch(arr, mid+1,right);``        ``else``            ``return` `binarySearch(arr, left, mid-1);``    ``}` `    ``return` `-1;``}` `// Driver program to run the case``int` `main()``{``    ``int` `arr[] = {6, 7, 8, 11, 9, 5, 2, 1};``    ``int` `n = ``sizeof``(arr)/``sizeof``(arr);``    ``int` `index = binarySearch(arr, 1, n-2);``    ``if` `(index != -1)``       ``cout << arr[index];``    ``return` `0;``}`

## Java

 `// Java program to find bitonic``// point in a bitonic array.` `import` `java.io.*;` `class` `GFG``{``    ``// Function to find bitonic point``    ``// using binary search``    ``static` `int` `binarySearch(``int` `arr[], ``int` `left,``                                       ``int` `right)``    ``{``        ``if` `(left <= right)``        ``{``            ``int` `mid = (left + right) / ``2``;``    ` `            ``// base condition to check if arr[mid]``            ``// is bitonic point or not``            ``if` `(arr[mid - ``1``] < arr[mid] &&``                   ``arr[mid] > arr[mid + ``1``])``                   ``return` `mid;``    ` `            ``// We assume that sequence is bitonic. We go to``            ``// right subarray if middle point is part of``            ``// increasing subsequence. Else we go to left``            ``// subarray.``            ``if` `(arr[mid] < arr[mid + ``1``])``                ``return` `binarySearch(arr, mid + ``1``, right);``            ``else``                ``return` `binarySearch(arr, left, mid - ``1``);``        ``}``    ` `        ``return` `-``1``;``    ``}``    ` `    ``// Driver program``    ``public` `static` `void` `main (String[] args)``    ``{``        ``int` `arr[] = {``6``, ``7``, ``8``, ``11``, ``9``, ``5``, ``2``, ``1``};``        ``int` `n = arr.length;``        ``int` `index = binarySearch(arr, ``1``, n - ``2``);``        ``if` `(index != -``1``)``        ``System.out.println ( arr[index]);``            ` `    ``}``}` `// This code is contributed by vt_m`

## Python3

 `# Python3 program to find bitonic``# point in a bitonic array.` `# Function to find bitonic point``# using binary search``def` `binarySearch(arr, left, right):` `    ``if` `(left <``=` `right):` `        ``mid ``=` `(left ``+` `right) ``/``/` `2``;` `        ``# base condition to check if``        ``# arr[mid] is bitonic point``        ``# or not``        ``if` `(arr[mid ``-` `1``] < arr[mid] ``and` `arr[mid] > arr[mid ``+` `1``]):``            ``return` `mid;` `        ``# We assume that sequence``        ``# is bitonic. We go to right``        ``# subarray if middle point``        ``# is part of increasing``        ``# subsequence. Else we go``        ``# to left subarray.``        ``if` `(arr[mid] < arr[mid ``+` `1``]):``            ``return` `binarySearch(arr, mid ``+` `1``,right);``        ``else``:``            ``return` `binarySearch(arr, left, mid ``-` `1``);` `    ``return` `-``1``;` `# Driver Code``arr ``=` `[``6``, ``7``, ``8``, ``11``, ``9``, ``5``, ``2``, ``1``];``n ``=` `len``(arr);``index ``=` `binarySearch(arr, ``1``, n``-``2``);``if` `(index !``=` `-``1``):``        ``print``(arr[index]);` `# This code is contributed by mits`

## C#

 `// C# program to find bitonic``// point in a bitonic array.``using` `System;` `class` `GFG``{``    ``// Function to find bitonic point``    ``// using binary search``    ``static` `int` `binarySearch(``int` `[]arr, ``int` `left,``                                      ``int` `right)``    ``{``        ``if` `(left <= right)``        ``{``            ``int` `mid = (left + right) / 2;``    ` `            ``// base condition to check if arr[mid]``            ``// is bitonic point or not``            ``if` `(arr[mid - 1] < arr[mid] &&``                ``arr[mid] > arr[mid + 1])``                ``return` `mid;``    ` `            ``// We assume that sequence is bitonic. We go``            ``// to right subarray if middle point is part of``            ``// increasing subsequence. Else we go to left subarray.``            ``if` `(arr[mid] < arr[mid + 1])``                ``return` `binarySearch(arr, mid + 1, right);``            ``else``                ``return` `binarySearch(arr, left, mid - 1);``        ``}``    ` `        ``return` `-1;``    ``}``    ` `    ``// Driver program``    ``public` `static` `void` `Main ()``    ``{``        ``int` `[]arr = {6, 7, 8, 11, 9, 5, 2, 1};``        ``int` `n = arr.Length;``        ``int` `index = binarySearch(arr, 1, n - 2);``        ``if` `(index != -1)``        ``Console.Write ( arr[index]);``    ``}``}` `// This code is contributed by nitin mittal`

## PHP

 ` ``\$arr``[``\$mid` `+ 1])``            ``return` `\$mid``;` `        ``// We assume that sequence``        ``// is bitonic. We go to right``        ``// subarray if middle point``        ``// is part of increasing``        ``// subsequence. Else we go``        ``// to left subarray.``        ``if` `(``\$arr``[``\$mid``] < ``\$arr``[``\$mid` `+ 1])``            ``return` `binarySearch(``\$arr``, ``\$mid` `+ 1,``\$right``);``        ``else``            ``return` `binarySearch(``\$arr``, ``\$left``, ``\$mid` `- 1);``    ``}` `    ``return` `-1;``}` `    ``// Driver Code``    ``\$arr` `= ``array``(6, 7, 8, 11, 9, 5, 2, 1);``    ``\$n` `= sizeof(``\$arr``);``    ``\$index` `= binarySearch(``\$arr``, 1, ``\$n``-2);``    ``if` `(``\$index` `!= -1)``        ``echo` `\$arr``[``\$index``];` `// This code is contributed by nitin mittal``?>`

## Javascript

 ``

Output

`11`

Time complexity: O(Log n)
Auxiliary Space: O(1), as no extra space is required

Approach 2 : (Iterative Solution)

Same approach is also followed here, implemented binary search in iterative way.

## C++14

 `// C++ program to find bitonic point in a bitonic array.``#include ``using` `namespace` `std;` `// Function to find bitonic point using binary search``int` `binarySearch(``int` `arr[], ``int` `low, ``int` `high)``{``    ``// binary search iterative``    ``while` `(low <= high)``    ``{``        ``// finding the mid index``        ``int` `mid = low + (high - low) / 2;``        ` `        ``// if both the values on either side``        ``// of mid index is lesser``        ``if` `(arr[mid] > arr[mid - 1]``            ``and arr[mid] > arr[mid + 1])``            ``return` `mid;``        ` `        ``// move to the right part``        ``else` `if` `(arr[mid] < arr[mid + 1])``            ``low = mid + 1;``        ` `        ``// move to the left part``        ``else``            ``high = mid - 1;``    ``}``    ` `    ``// not found``    ``return` `-1;``}` `// Driver program to run the case``int` `main()``{``    ``int` `arr[] = { 6, 7, 8, 11, 9, 5, 2, 1 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``int` `index = binarySearch(arr, 1, n - 2);``    ``if` `(index != -1)``        ``cout << arr[index];``    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */``import` `java.io.*;``class` `GFG {` `  ``// Function to find bitonic point using binary search``  ``static` `int` `binarySearch(``int` `arr[], ``int` `low, ``int` `high)``  ``{``    ``// binary search iterative``    ``while` `(low <= high)``    ``{``      ``// finding the mid index``      ``int` `mid = low + (high - low) / ``2``;` `      ``// if both the values on either side``      ``// of mid index is lesser``      ``if``(arr[mid] > arr[mid - ``1``] && arr[mid] > arr[mid + ``1``])``        ``return` `mid;` `      ``// move to the right part``      ``else` `if` `(arr[mid] < arr[mid + ``1``])``        ``low = mid + ``1``;` `      ``// move to the left part``      ``else``        ``high = mid - ``1``;``    ``}` `    ``// not found``    ``return` `-``1``;``  ``}` `  ``public` `static` `void` `main (String[] args)``  ``{``    ``int` `arr[] = { ``6``, ``7``, ``8``, ``11``, ``9``, ``5``, ``2``, ``1` `};``    ``int` `n = arr.length;``    ``int` `index = binarySearch(arr, ``1``, n - ``2``);``    ``if` `(index != -``1``)``      ``System.out.println(arr[index]);``  ``}``}` `// This code is contributed by aadityaburujwale.`

## Python3

 `# python program to find bitonic point in a bitonic array.``# Function to find bitonic point using Binary Search``def` `binary_search(arr, low, high):``    ` `    ``# binary search iterativ``    ``while``(low <``=` `high):``      ` `        ``# finding the mid index``        ``mid ``=` `low ``+` `(high ``-` `low) ``/``/` `2``        ` `        ``# if both the values on either side``        ``# of mid index is lesser``        ``if``(arr[mid] > arr[mid ``-` `1``] ``and` `arr[mid] > arr[mid ``+` `1``]):``            ``return` `mid``        ``# move to the right part``        ``elif``(arr[mid] < arr[mid ``+` `1``]):``            ``low ``=` `mid ``+` `1``            ` `        ``# move to the right part``        ``else``:``            ``high ``=` `mid ``-` `1``    ``# Not Found``    ``return` `-``1` `# Driver Code``arr ``=` `[ ``6``, ``7``, ``8``, ``11``, ``9``, ``5``, ``2``, ``1``]``n ``=` `len``(arr)``idx ``=` `binary_search(arr, ``1``, n ``-` `2``)``if``(idx !``=` `-``1``):``    ``print``(arr[idx])``    ` `    ``# This code is contributed by vibhukarnwal077`

## C#

 `using` `System;` `public` `class` `GFG {` `  ``// Function to find bitonic point using binary search``  ``static` `int` `binarySearch(``int``[] arr, ``int` `low, ``int` `high)``  ``{``    ``// binary search iterative``    ``while` `(low <= high)``    ``{``      ` `      ``// finding the mid index``      ``int` `mid = low + (high - low) / 2;` `      ``// if both the values on either side``      ``// of mid index is lesser``      ``if` `(arr[mid] > arr[mid - 1]``          ``&& arr[mid] > arr[mid + 1])``        ``return` `mid;` `      ``// move to the right part``      ``else` `if` `(arr[mid] < arr[mid + 1])``        ``low = mid + 1;` `      ``// move to the left part``      ``else``        ``high = mid - 1;``    ``}` `    ``// not found``    ``return` `-1;``  ``}` `  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``int``[] arr = { 6, 7, 8, 11, 9, 5, 2, 1 };``    ``int` `n = arr.Length;``    ``int` `index = binarySearch(arr, 1, n - 2);``    ``if` `(index != -1)``      ``Console.WriteLine(arr[index]);``  ``}``}` `// This code is contributed by karandeep1234.`

## Javascript

 `   ``// Function to find bitonic point using binary search``   ``function` `binarySearch(arr, low, high)``   ``{``       ``// binary search iterative``       ``while` `(low <= high)``       ``{``           ``// finding the mid index``           ``var` `mid = low + parseInt((high - low) / 2);``           ``// if both the values on either side``           ``// of mid index is lesser``           ``if` `(arr[mid] > arr[mid - 1] && arr[mid] > arr[mid + 1])``           ``{``               ``return` `mid;``           ``}``           ``else` `if` `(arr[mid] < arr[mid + 1])``           ``{``               ``low = mid + 1;``           ``}``           ``else``           ``{``               ``high = mid - 1;``           ``}``       ``}``       ` `       ``// not found``       ``return` `-1;``   ``}``   ` `       ``var` `arr = [6, 7, 8, 11, 9, 5, 2, 1];``       ``var` `n = arr.length;``       ``var` `index = binarySearch(arr, 1, n - 2);``       ``if` `(index != -1)``       ``{``           ``console.log(arr[index]);``       ``}` `// This code is contributed by sourabhdalal0001.`

Output

`11`

Time complexity : O(log n)
Auxiliary Space: O(1), as no extra space is required

This article is contributed by Shashank Mishra ( Gullu ). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up