Open In App

Search an element in a reverse sorted array

Improve
Improve
Like Article
Like
Save
Share
Report

Given an array arr[] sorted in decreasing order, and an integer X, the task is to check if X is present in the given array or not. If X is present in the array, print its index ( 0-based indexing). Otherwise, print -1.

Examples: 

Input: arr[] = {5, 4, 3, 2, 1}, X = 4
Output: 1
Explanation: Element X (= 4) is present at index 1.
Therefore, the required output is 1.

Input: arr[] = {10, 8, 2, -9}, X = 5
Output: -1
Explanation: Element X (= 5) is not present in the array.
Therefore, the required output is -1.

 

Naive Approach: The simplest approach to solve the problem is to traverse the array and for each element, check if it is equal to X or not. If any element is found to satisfy that condition, print the index of that element. Otherwise print -1

Time Complexity: O(N) 
Auxiliary Space: O(1)

Efficient Approach: To solve the problem, the idea is to use Binary Search based on the approach discussed in the article search an element in a sorted array. Follow the steps below to solve the problem: 

  1. Compare X with the middle element.
  2. If X matches with the middle element (arr[mid]), return the index mid.
  3. If X is found to be greater than the arr[mid], then X can only lie in the subarray [mid + 1, end]. So search for X in the subarray {arr[mid + 1], .., arr[end]} .
  4. Otherwise, search in the subarray {arr[start], …., arr[mid]}

Below is the implementation of the above approach:

C




// C program for the above approach
#include <stdio.h>
 
// Function to search if element X
// is present in reverse sorted array
int binarySearch(int arr[], int N, int X)
{
    // Store the first index of the
    // subarray in which X lies
    int start = 0;
 
    // Store the last index of the
    // subarray in which X lies
    int end = N;
 
    while (start <= end) {
 
        // Store the middle index
        // of the subarray
        int mid = start
                  + (end - start) / 2;
 
        // Check if value at middle index
        // of the subarray equal to X
        if (X == arr[mid]) {
 
            // Element is found
            return mid;
        }
 
        // If X is smaller than the value
        // at middle index of the subarray
        else if (X < arr[mid]) {
 
            // Search in right
            // half of subarray
            start = mid + 1;
        }
        else {
 
            // Search in left
            // half of subarray
            end = mid - 1;
        }
    }
 
    // If X not found
    return -1;
}
 
// Driver Code
int main()
{
    int arr[] = { 5, 4, 3, 2, 1 };
    int N = sizeof(arr) / sizeof(arr[0]);
    int X = 4;
      
    int res =  binarySearch(arr, N, X);
    printf(" %d " , res);
    return 0;
}
//This code is contributed by Pradeep Mondal P


C++




// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to search if element X
// is present in reverse sorted array
int binarySearch(int arr[], int N, int X)
{
    // Store the first index of the
    // subarray in which X lies
    int start = 0;
 
    // Store the last index of the
    // subarray in which X lies
    int end = N;
 
    while (start <= end) {
 
        // Store the middle index
        // of the subarray
        int mid = start
                  + (end - start) / 2;
 
        // Check if value at middle index
        // of the subarray equal to X
        if (X == arr[mid]) {
 
            // Element is found
            return mid;
        }
 
        // If X is smaller than the value
        // at middle index of the subarray
        else if (X < arr[mid]) {
 
            // Search in right
            // half of subarray
            start = mid + 1;
        }
        else {
 
            // Search in left
            // half of subarray
            end = mid - 1;
        }
    }
 
    // If X not found
    return -1;
}
 
// Driver Code
int main()
{
    int arr[] = { 5, 4, 3, 2, 1 };
    int N = sizeof(arr) / sizeof(arr[0]);
    int X = 5;
    cout << binarySearch(arr, N, X);
    return 0;
}


Java




// Java Program to implement
// the above approach
class GFG {
 
    // Function to search if element X
    // is present in reverse sorted array
    static int binarySearch(int arr[],
                            int N, int X)
    {
        // Store the first index of the
        // subarray in which X lies
        int start = 0;
 
        // Store the last index of the
        // subarray in which X lies
        int end = N;
        while (start <= end) {
 
            // Store the middle index
            // of the subarray
            int mid = start
                      + (end - start) / 2;
 
            // Check if value at middle index
            // of the subarray equal to X
            if (X == arr[mid]) {
 
                // Element is found
                return mid;
            }
 
            // If X is smaller than the value
            // at middle index of the subarray
            else if (X < arr[mid]) {
 
                // Search in right
                // half of subarray
                start = mid + 1;
            }
            else {
 
                // Search in left
                // half of subarray
                end = mid - 1;
            }
        }
 
        // If X not found
        return -1;
    }
    public static void main(String[] args)
    {
        int arr[] = { 5, 4, 3, 2, 1 };
        int N = arr.length;
        int X = 5;
        System.out.println(
            binarySearch(arr, N, X));
    }
}


Python3




# Python3 program to implement
# the above approach
 
# Function to search if element X
# is present in reverse sorted array
def binarySearch(arr, N, X):
     
    # Store the first index of the
    # subarray in which X lies
    start = 0
 
    # Store the last index of the
    # subarray in which X lies
    end = N
 
    while (start <= end):
 
        # Store the middle index
        # of the subarray
        mid = start + (end - start) // 2
 
        # Check if value at middle index
        # of the subarray equal to X
        if (X == arr[mid]):
 
            # Element is found
            return mid
 
        # If X is smaller than the value
        # at middle index of the subarray
        elif (X < arr[mid]):
 
            # Search in right
            # half of subarray
            start = mid + 1
        else:
 
            # Search in left
            # half of subarray
            end = mid - 1
 
    # If X not found
    return -1
 
# Driver Code
if __name__ == '__main__':
     
    arr = [ 5, 4, 3, 2, 1 ]
    N = len(arr)
    X = 5
     
    print(binarySearch(arr, N, X))
 
# This code is contributed by mohit kumar 29


C#




// C# Program to implement
// the above approach
using System;
class GFG{
 
// Function to search if element X
// is present in reverse sorted array
static int binarySearch(int []arr,
                        int N, int X)
{
  // Store the first index of the
  // subarray in which X lies
  int start = 0;
 
  // Store the last index of the
  // subarray in which X lies
  int end = N;
  while (start <= end)
  {
    // Store the middle index
    // of the subarray
    int mid = start +
              (end - start) / 2;
 
    // Check if value at middle index
    // of the subarray equal to X
    if (X == arr[mid])
    {
      // Element is found
      return mid;
    }
 
    // If X is smaller than the value
    // at middle index of the subarray
    else if (X < arr[mid])
    {
      // Search in right
      // half of subarray
      start = mid + 1;
    }
    else
    {
      // Search in left
      // half of subarray
      end = mid - 1;
    }
  }
 
  // If X not found
  return -1;
}
 
// Driver code
public static void Main(String[] args)
{
  int []arr = {5, 4, 3, 2, 1};
  int N = arr.Length;
  int X = 5;
  Console.WriteLine(binarySearch(arr, N, X));
}
}
 
// This code is contributed by Princi Singh


Javascript




<script>
// JavaScript program to implement
// the above approach
 
// Function to search if element X
// is present in reverse sorted array
function binarySearch(arr, N, X)
{
    // Store the first index of the
    // subarray in which X lies
    let start = 0;
 
    // Store the last index of the
    // subarray in which X lies
    let end = N;
 
    while (start <= end) {
 
        // Store the middle index
        // of the subarray
        let mid = Math.floor(start
                + (end - start) / 2);
 
        // Check if value at middle index
        // of the subarray equal to X
        if (X == arr[mid]) {
 
            // Element is found
            return mid;
        }
 
        // If X is smaller than the value
        // at middle index of the subarray
        else if (X < arr[mid]) {
 
            // Search in right
            // half of subarray
            start = mid + 1;
        }
        else {
 
            // Search in left
            // half of subarray
            end = mid - 1;
        }
    }
 
    // If X not found
    return -1;
}
 
// Driver Code
    let arr = [ 5, 4, 3, 2, 1 ];
    let N = arr.length;
    let X = 5;
    document.write(binarySearch(arr, N, X));
 
     
 
 
 
// This code is contributed by Surbhi Tyagi.
</script>


Output: 

1

 

Time Complexity: O(log2N)
Auxiliary Space: O(1)



Last Updated : 07 May, 2021
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads