Introduction to Searching

import java.io.*;

class GFG {
    public static int search(int arr[], int N, int x)
    {
        // Iterate over the array in order to
        // find the key x
        for (int i = 0; i < N; i++) {
            if (arr[i] == x)
                return i;
        }
        return -1;
    }

    public static void main(String args[])
    {
        int arr[] = { 2, 3, 4, 10, 40 };
        int x = 10;

        int result = search(arr, arr.length, x);
        if (result == -1)
            System.out.print(
                "Element is not present in array");
        else
            System.out.print("Element is present at index "
                             + result);
    }
}

class GFG {
    
    // A recursive binary search function. It returns
    // location of x in given array arr[low..high] is present,
    // otherwise -1    
    static int binarySearch(int arr[], int low, int high, int x) {
        if (high >= low) {
            int mid = low + (high - low) / 2;

            // If the element is present at the
            // middle itself
            if (arr[mid] == x)
                return mid;

            // If element is smaller than mid, then
            // it can only be present in left subarray
            if (arr[mid] > x)
                return binarySearch(arr, low, mid - 1, x);

            // Else the element can only be present
            // in right subarray
            return binarySearch(arr, mid + 1, high, x);
        }

        // We reach here when element is not present
        // in array
        return -1;
    }

    public static void main(String args[])
    {
        int arr[] = { 2, 3, 4, 10, 40 };
        int n = arr.length;
        int x = 10;
        int result = binarySearch(arr, 0, n - 1, x);
        if (result == -1)
            System.out.println(
                "Element is not present in array");
        else
            System.out.println(
                "Element is present at index " + result);
    }
}

class GfG {

    public static int findMinIndex(int[] arr) {
        int low = 0, high = arr.length - 1;
        int minIndex = -1;

        while (low <= high) {

            // divide the range into three parts
            int mid1 = low + (high - low) / 3;
            int mid2 = high - (high - low) / 3;

            // if both mid1 and mid2 point to equal 
            // values narrow the search
            if (arr[mid1] == arr[mid2]) {

                // Move towards the center
                low = mid1 + 1;
                high = mid2 - 1;

                // tentatively store mid1 as
                // potential minimum
                minIndex = mid1;
            }

            // if arr[mid1] < arr[mid2], the minimum lies in the
            // left part (including mid1)
            else if (arr[mid1] < arr[mid2]) {
                high = mid2 - 1;

                // update with better candidate
                minIndex = mid1;
            }

            // is arr[mid1] > arr[mid2], the minimum lies in the
            // right part (including mid2)
            else {
                low = mid1 + 1;

                // update with better candidate
                minIndex = mid2;
            }
        }

        return minIndex;
    }

    public static void main(String[] args) {
        int[] arr = {9, 7, 1, 2, 3, 6, 10};
        int idx = findMinIndex(arr);
        System.out.println(idx);
    }
}