Skip to content
Related Articles

Related Articles

Search an element in an unsorted array using minimum number of comparisons

Given an array of n distinct integers and an element x. Search the element x in the array using minimum number of comparisons. Any sort of comparison will contribute 1 to the count of comparisons. For example, the condition used to terminate a loop, will also contribute 1 to the count of comparisons each time it gets executed. Expressions like while (n) {n–;} also contribute to the count of comparisons as value of n is being compared internally so as to decide whether or not to terminate the loop. 
Examples: 
 

Input : arr[] = {4, 6, 1, 5, 8}, 
        x = 1
Output : Found

Input : arr[] = {10, 3, 12, 7, 2, 11, 9}, 
        x = 15
Output : Not Found

Asked in Adobe Interview

 

Below simple method to search requires 2n + 1 comparisons in worst case. 
 

for (i = 0; i < n; i++)  // Worst case n+1
   if (arr[i] == x)  // Worst case n
       return i;

How to reduce number of comparisons? 
The idea is to copy x (element to be searched) to last location so that one last comparison when x is not present in arr[] is saved.
Algorithm: 
 



search(arr, n, x)
    if arr[n-1] == x  // 1 comparison
       return "true"
    backup = arr[n-1]
    arr[n-1] = x

    for i=0, i++ // no termination condition
        if arr[i] == x // execute at most n times
                       // that is at-most n comparisons
            arr[n-1] = backup
            return (i < n-1) // 1 comparison

 

C/C++


// C++ implementation to search an element in
// the unsorted array using minimum number of
// comparisons
#include <bits/stdc++.h>
using namespace std;

// function to search an element in
// minimum number of comparisons
string search(int arr[], int n, int x)
{
    // 1st comparison
    if (arr[n - 1] == x)
        return "Found";

    int backup = arr[n - 1];
    arr[n - 1] = x;

    // no termination condition and thus
    // no comparison
    for (int i = 0;; i++) {
        // this would be executed at-most n times
        // and therefore at-most n comparisons
        if (arr[i] == x) {
            // replace arr[n-1] with its actual element
            // as in original 'arr[]'
            arr[n - 1] = backup;

            // if 'x' is found before the '(n-1)th'
            // index, then it is present in the array
            // final comparison
            if (i < n - 1)
                return "Found";

            // else not present in the array
            return "Not Found";
        }
    }
}

// Driver program to test above
int main()
{
    int arr[] = { 4, 6, 1, 5, 8 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int x = 1;
    cout << search(arr, n, x);
    return 0;
}

Java




// Java implementation to search an element in
// the unsorted array using minimum number of
// comparisons
import java.io.*;
 
class GFG {
 
    // Function to search an element in
    // minimum number of comparisons
    static String search(int arr[], int n, int x)
    {
        // 1st comparison
        if (arr[n - 1] == x)
            return "Found";
 
        int backup = arr[n - 1];
        arr[n - 1] = x;
 
        // no termination condition and thus
        // no comparison
        for (int i = 0;; i++) {
            // this would be executed at-most n times
            // and therefore at-most n comparisons
            if (arr[i] == x) {
                // replace arr[n-1] with its actual element
                // as in original 'arr[]'
                arr[n - 1] = backup;
 
                // if 'x' is found before the '(n-1)th'
                // index, then it is present in the array
                // final comparison
                if (i < n - 1)
                    return "Found";
 
                // else not present in the array
                return "Not Found";
            }
        }
    }
 
    // driver program
    public static void main(String[] args)
    {
        int arr[] = { 4, 6, 1, 5, 8 };
        int n = arr.length;
        int x = 1;
        System.out.println(search(arr, n, x));
    }
}
 
// Contributed by Pramod Kumar

Python3




# Python3 implementation to search an
# element in the unsorted array using
# minimum number of comparisons
 
# function to search an element in
# minimum number of comparisons
def search(arr, n, x):
     
    # 1st comparison
    if (arr[n-1] == x) :
        return "Found"
 
    backup = arr[n-1]
    arr[n-1] = x
 
    # no termination condition and
    # thus no comparison
    i = 0
    while(i < n) :
         
        # this would be executed at-most n times
        # and therefore at-most n comparisons
        if (arr[i] == x) :
             
            # replace arr[n-1] with its actual
            # element as in original 'arr[]'
            arr[n-1] = backup
 
            # if 'x' is found before the '(n-1)th'
            # index, then it is present in the
            # array final comparison
            if (i < n-1):
                return "Found"
 
            # else not present in the array
            return "Not Found"
        i = i + 1
 
# Driver Code
arr = [4, 6, 1, 5, 8]
n = len(arr)
x = 1
print (search(arr, n, x))
 
# This code is contributed by rishabh_jain

C#




// C# implementation to search an
// element in the unsorted array
// using minimum number of comparisons
using System;
 
class GFG {
     
    // Function to search an element in
    // minimum number of comparisons
    static String search(int[] arr, int n, int x)
    {
        // 1st comparison
        if (arr[n - 1] == x)
            return "Found";
 
        int backup = arr[n - 1];
        arr[n - 1] = x;
 
        // no termination condition and thus
        // no comparison
        for (int i = 0;; i++) {
             
            // this would be executed at-most n times
            // and therefore at-most n comparisons
            if (arr[i] == x) {
                 
                // replace arr[n-1] with its actual element
                // as in original 'arr[]'
                arr[n - 1] = backup;
 
                // if 'x' is found before the '(n-1)th'
                // index, then it is present in the array
                // final comparison
                if (i < n - 1)
                    return "Found";
 
                // else not present in the array
                return "Not Found";
            }
        }
    }
 
    // driver program
    public static void Main()
    {
        int[] arr = { 4, 6, 1, 5, 8 };
        int n = arr.Length;
        int x = 1;
        Console.WriteLine(search(arr, n, x));
    }
}
 
// This code is contributed by Sam007

PHP




<?php
// PHP implementation to
// search an element in
// the unsorted array
// using minimum number of
// comparisons
 
// function to search an
// element in minimum
// number of comparisons
function search($arr, $n, $x)
{
     
    // 1st comparison
    if ($arr[$n - 1] == $x)
        return "Found";
 
    $backup = $arr[$n - 1];
    $arr[$n - 1] = $x;
 
    // no termination
    // condition and thus
    // no comparison
    for ($i = 0; ; $i++)
    {
         
        // this would be executed
        // at-most n times and
        // therefore at-most
        // n comparisons
        if ($arr[$i] == $x)
        {
             
            // replace arr[n-1]
            // with its actual element
            // as in original 'arr[]'
            $arr[$n - 1] = $backup;
 
            // if 'x' is found before
            // the '(n-1)th' index,
            // then it is present
            // in the array
            // final comparison
            if ($i < $n - 1)
                return "Found";
 
            // else not present
            // in the array
            return "Not Found";
        }
    }
}
 
// Driver Code
$arr = array( 4, 6, 1, 5, 8 );
$n = sizeof($arr);
$x = 1;
echo(search($arr, $n, $x));
 
// This code is contributed by Ajit.
?>

Javascript




<script>
    // Javascript implementation to search an
    // element in the unsorted array
    // using minimum number of comparisons
     
    // Function to search an element in
    // minimum number of comparisons
    function search(arr, n, x)
    {
        // 1st comparison
        if (arr[n - 1] == x)
            return "Found";
   
        let backup = arr[n - 1];
        arr[n - 1] = x;
   
        // no termination condition and thus
        // no comparison
        for (let i = 0;; i++) {
               
            // this would be executed at-most n times
            // and therefore at-most n comparisons
            if (arr[i] == x) {
                   
                // replace arr[n-1] with its actual element
                // as in original 'arr[]'
                arr[n - 1] = backup;
   
                // if 'x' is found before the '(n-1)th'
                // index, then it is present in the array
                // final comparison
                if (i < n - 1)
                    return "Found";
   
                // else not present in the array
                return "Not Found";
            }
        }
    }
     
    let arr = [ 4, 6, 1, 5, 8 ];
    let n = arr.length;
    let x = 1;
    document.write(search(arr, n, x));
 
</script>

Output: 
 

Found

Time Complexity: O(n) 
Number of Comparisons: Atmost (n+2) comparisons
This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 

My Personal Notes arrow_drop_up
Recommended Articles
Page :