Question

can anyone solve this in java with algorithm pseducode based on the code please

Description Perform an empirical study to compare the performance of binary and interpolation search for an application which is expected to process datasets of integers in the range -500000 of unspecified sizes. The study should provide insights into these methods

Answer 1

On average the interpolation search makes about log(log(n)) comparisons (if the elements are uniformly distributed), where n is the number of elements to be searched. In the worst case (for instance where the numerical values of the keys increase exponentially) it can make up to O(n) comparisons.

The pseudocode of binary search algorithms should look like this −

Procedure binary_search
   A ← sorted array
   n ← size of array
   x ← value to be searched

   Set lowerBound = 1
   Set upperBound = n 

   while x not found
      if upperBound < lowerBound 
         EXIT: x does not exists.
   
      set midPoint = lowerBound + ( upperBound - lowerBound ) / 2
      
      if A[midPoint] < x
         set lowerBound = midPoint + 1
         
      if A[midPoint] > x
         set upperBound = midPoint - 1 

      if A[midPoint] = x 
         EXIT: x found at location midPoint
   end while
   
end procedure

The pseudocode of interpolation search algorithms should look like this −

A → Array list
N → Size of A
X → Target Value

Procedure Interpolation_Search()

   Set Lo  →  0
   Set Mid → -1
   Set Hi  →  N-1

   While X does not match
   
      if Lo equals to Hi OR A[Lo] equals to A[Hi]
         EXIT: Failure, Target not found
      end if
      
      Set Mid = Lo + ((Hi - Lo) / (A[Hi] - A[Lo])) * (X - A[Lo]) 

      if A[Mid] = X
         EXIT: Success, Target found at Mid
      else 
         if A[Mid] < X
            Set Lo to Mid+1
         else if A[Mid] > X
            Set Hi to Mid-1
         end if
      end if
   End While

End Procedure

Java example source code-

EmpiricalStudy.java

public class EmpiricalStudy {

   public static int binarySearch(int arr[], int first, int last, int key){
       int mid = (first + last)/2;
       while( first <= last ){
           if ( arr[mid] < key ){
               first = mid + 1;   
           }else if ( arr[mid] == key ){
               return mid;
           }else{
               last = mid - 1;
           }
           mid = (first + last)/2;
       }
       return -1;
   }
   public static int interpolationSearch(int arr[], int n, int x)
   {
       // Find indexes of two corners
       int lo = 0, hi = (n - 1);

       // Since array is sorted, an element present
       // in array must be in range defined by corner
       while (lo <= hi && x >= arr[lo] && x <= arr[hi])
       {
           if (lo == hi)
           {
               if (arr[lo] == x) return lo;
               return -1;
           }
           // Probing the position with keeping
           // uniform distribution in mind.
           int pos = (int) (lo + (((double)(hi - lo) /
                   (arr[hi] - arr[lo])) * (x - arr[lo])));

           // Condition of target found
           if (arr[pos] == x)
               return pos;

           // If x is larger, x is in upper part
           if (arr[pos] < x)
               lo = pos + 1;

           // If x is smaller, x is in the lower part
           else
               hi = pos - 1;
       }
       return -1;
   }

   public static void main(String[] args) {
       // Array of items on which search will
       // be conducted.
       int arr[] = new int[500000];

       for(int i=0;i<500000;i++)
       {
           arr[i]=i;
       }
       int n = arr.length;

       int x = 18; // Element to be searched

       long start = System.currentTimeMillis();
       int index = interpolationSearch(arr, n, x);
       long end = System.currentTimeMillis();
      
       // If element was found
       if (index != -1)
           System.out.println("Interpolation Search found element at index "+index+" in "+(end - start) + " millisec");
       else
           System.out.println("Element not found.");
      
       start = System.currentTimeMillis();
       index = binarySearch(arr, 0, n, x);
       end = System.currentTimeMillis();
      
       // If element was found
       if (index != -1)
           System.out.println("Binary Search found element at index "+index+" in "+(end - start) + "millisec");
       else
           System.out.println("Element not found.");
   }
}