Question

I have the following classes

SearchMain.java

import java.security.SecureRandom;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

/**
*
* DO NOT CHANGE THIS CODE
*
*/
public class SearchMain {
   public static void main(String[] args) {
       ArraySearcher arraySearch = new ArraySearchImp();
       SecureRandom secureRandom = new SecureRandom();
       int[] sortedArray = generateRandomSortedIntArray(10);
       System.out.println(Arrays.toString(sortedArray));
       Set<Integer> intSet = new HashSet<Integer>();
      
       for(int i = 0; i < 5; i++) {
           int randomInt;
           do {
               randomInt = sortedArray[secureRandom.nextInt(sortedArray.length-1)+1];
           } while(intSet.contains(randomInt));
          
           intSet.add(randomInt);
           testSearchMethods(arraySearch, sortedArray, randomInt);
       }
      
       testSearchMethods(arraySearch, sortedArray, sortedArray[0]);
       testSearchMethods(arraySearch, sortedArray, sortedArray[sortedArray.length-1]);
       testSearchMethods(arraySearch, sortedArray, sortedArray[sortedArray.length-1] + 1);
       testSearchMethods(arraySearch, sortedArray, sortedArray[0] -1);
       testSearchMethods(arraySearch, sortedArray, -10);
   }
  
   private static void testSearchMethods(ArraySearcher arraySearch, int[] sortedArray, int valueToSearchFor) {
       int result = Arrays.binarySearch(sortedArray, valueToSearchFor);
       result = result < 0 ? -1 : result;
      
       System.out.println("\nValue to search for: "+ valueToSearchFor + "; expected result: " + result);
      
       System.out.print("Linear search...");
       int linearSearchResult                = arraySearch.linearSearch(sortedArray, valueToSearchFor);
       if(result == linearSearchResult) {
           System.out.println("[OK]");
       } else {
           System.out.println("[ X ] - index returned: " + linearSearchResult);
       }
      
       System.out.print("Binary search...");
       int binarySearchResult                = arraySearch.binarySearch(sortedArray, valueToSearchFor);
       if(result == binarySearchResult) {
           System.out.println("[OK]");
       } else {
           System.out.println("[ X ] - index returned: " + binarySearchResult);
       }
      
       System.out.print("Binary search...");
       int binarySearchRecursiveResult    = arraySearch.binarySearchRecursive(sortedArray, valueToSearchFor);
       if(result == binarySearchRecursiveResult) {
           System.out.println("[OK]");
       } else {
           System.out.println("[ X ] - index returned: " + binarySearchRecursiveResult);
       }
   }
  
   private static int[] generateRandomSortedIntArray(int arraySize) {
       SecureRandom secureRandom = new SecureRandom();
      
       int[] array = new int[arraySize];
       int previousInt = 0;
      
       for(int i = 0; i < array.length; i++) {
           int randomInt = secureRandom.nextInt(10) + 1;
           array[i] = previousInt + randomInt;
           previousInt = array[i];
       }
      
       return array;
   }
}

----------------------------------------------

ArraySearcher.java

/**
*
* DO NOT CHANGE THIS CODE
*
*/
public interface ArraySearcher {
   /**
   *
   * Also known as sequential search
   *
   * @param array               - an int[] array
   * @param valueToSearchFor   - the value to search for
   * @return index of <valueToSearchFor> if found in <sortedArray>, -1 otherwise
   */
   public int linearSearch(int[] array, int valueToSearchFor);
  
   /**
   *
   * The non-recursive version of binarySearch
   *
   * @param sortedArray       - the array must be sorted
   * @param valueToSearchFor   - the value to search for
   * @return index of <valueToSearchFor> if found in <sortedArray>, -1 otherwise
   */
   public int binarySearch(int[] sortedArray, int valueToSearchFor);
  
   /**
   *
   * The recursive version of binarySearch
   *
   * @param sortedArray       - the array must be sorted
   * @param valueToSearchFor   - the value to search for
   * @return index of <valueToSearchFor> if found in <sortedArray>, -1 otherwise
   */
   public int binarySearchRecursive(int[] sortedArray, int valueToSearchFor);
}

---------------------------------------

I need to create

ArraySearchImp.java

to output the following

----------------------------------

------------- A sample run of SearchMain.java which shows correct implementation ---------

[4, 12, 20, 23, 31, 33, 43, 44, 45, 48]

Value to search for: 33; expected result: 5 Linear search.................. [OK]

Binary search.. [OK]

Binary search.. [OK]

Value to search for: 45; expected result: 8 Linear search.................. [OK]

Binary search.. [OK]

Binary search.. [OK]

Value to search for: 23; expected result: 3 Linear search.................. [OK]

Binary search.. [OK]

Binary search.. [OK]

Value to search for: 44; expected result: 7 Linear search.................. [OK]

Binary search.. [OK]

Binary search.. [OK]

Value to search for: 48; expected result: 9 Linear search.................. [OK]

Binary search.. [OK]

Binary search.. [OK]

Value to search for: 4; expected result: 0 Linear search...[OK]

Binary search...[OK] Binary search...[OK]

Value to search for: 48; expected result: 9 Linear search...[OK]

Binary search...[OK] Binary search...[OK]

Value to search for: 49; expected result: -1 Linear search...[OK]

Binary search...[OK] Binary search...[OK]

Value to search for: 3; expected result: -1 Linear search...[OK]

Binary search...[OK] Binary search...[OK]

Value to search for: -10; expected result: -1 Linear search...[OK]

Binary search...[OK] Binary search...[OK]

-----------------------------------------------------------------

Answer 1

Below is the code in JAVA for the above question:

(ArraySearchImp.java)

//class ArraySearchImp that implements ArraySearcher.
public class ArraySearchImp implements ArraySearcher {
   //method linear Search.
   @Override
   public int linearSearch(int[] array, int valueToSearchFor) {
       // TODO Auto-generated method stub
       //length of array.
       int n = array.length;
      
       //searching value using linear search
       for (int i = 0; i < n; i++) {
           //if value at i in array is equal to valueToSearchFor
           if (array[i] == valueToSearchFor)
               //returning index if found.
               return i;
       }
       //returning -1 if not found.
       return -1;
   }
  
   //iterative binary search method.
   @Override
   public int binarySearch(int[] sortedArray, int valueToSearchFor) {
       // TODO Auto-generated method stub
      
       int left = 0, right = sortedArray.length - 1;
      
       //iterating till left is less than or equal to right.
       while (left <= right) {
           //finding mid index of sortedArray
           int mid = (left + right) / 2;
          
           //if element at index mid is equal to valueToSearchFor
           if (sortedArray[mid] == valueToSearchFor)
               return mid;
          
           //if element at index mid is less than valueToSearchFor
           if (sortedArray[mid] < valueToSearchFor)
               left = mid + 1;
           else
               right = mid - 1;
       }
       //returning -1 if not found.
       return -1;
   }

   @Override
   public int binarySearchRecursive(int[] sortedArray, int valueToSearchFor) {
       // TODO Auto-generated method stub
       //finding index using helper method of binarySearchRecursive.
       int find = binarySearchRecursiveHelper(sortedArray, valueToSearchFor, 0, sortedArray.length - 1);
       //returning index of the element which is stored in variable find.
       return find;
   }
  
   //helper function to find element using binary search recursively.
   public int binarySearchRecursiveHelper(int[] sortedArray, int valueToSearchFor, int left, int right) {

       if (right >= left) {
           int mid = (left + right) / 2;
          
           //if value at index mid is equal to valueToSearchFor
           if (sortedArray[mid] == valueToSearchFor)
               return mid;
           //if value at index mid is greater than valueToSearchFor
           if (sortedArray[mid] > valueToSearchFor)
               return binarySearchRecursiveHelper(sortedArray, valueToSearchFor, left, mid - 1);
          
           //if value at index mid is less than valueToSearchFor
           if (sortedArray[mid] < valueToSearchFor)
               return binarySearchRecursiveHelper(sortedArray, valueToSearchFor, mid + 1, right);
       }
       //returns -1 if not found.
       return -1;
   }
}

Refer to the screenshot attached below to better understand the code and indentation:

(ArraySearchImp.java)




Output:



If this answer helps you then please upvote,
for further queries comment below.

Thank you.