用于二进制搜索的Java程序（递归和迭代）

因此，众所周知，二分搜索是处理数据结构时最常应用的搜索算法之一，其古怪的目标是不遍历整个数组。这里数组必须排序，因为我们检查中间元素并忽略数组的一半，根据数字系统没有用。我们基本上在一次比较之后就忽略了一半的元素。所以我们是否继续迭代直到找到元素或得出元素不存在于数组中的结论。

算法：

1. 将 x 与中间元素进行比较。
2. 如果 x 与中间元素匹配，我们返回中间索引。
3. Else 如果 x 大于中间元素，则 x 只能位于中间元素之后的右半子数组中。所以我们重复右半部分。
4. 否则（x 更小）在左半边重复出现。

示例 1

Java

// Java Program to Illustrate
// Iterative Binary Search
 
// Main class
// BinarySearch
class GFG {
 
    // Method 1
    // Returns index of x
    // if it is present in arr[],
    // else return -1
    int binarySearch(int arr[], int x)
    {
 
        int l = 0, r = arr.length - 1;
 
        // Checking element in whole array
        while (l <= r) {
            int m = l + (r - l) / 2;
 
            // Check if x is present at mid
            if (arr[m] == x)
                return m;
 
            // If x greater, ignore left half
            if (arr[m] < x)
                l = m + 1;
 
            // If x is smaller,
            // element is on left side
            // so ignore right half
            else
                r = m - 1;
        }
 
        // If we reach here,
        // element is not present
        return -1;
    }
 
    // Method 2
    // Main driver method
    public static void main(String args[])
    {
 
        GFG ob = new GFG();
 
        // Input array
        int arr[] = { 2, 3, 4, 10, 40 };
        // Length of array
        int n = arr.length;
        // Element to be checked if present or not
        int x = 10;
 
        // Calling the method 1 and
        // storing result
        int result = ob.binarySearch(arr, x);
 
        // Element present
        if (result == -1)
 
            // Print statement
            System.out.println("Element not present");
 
        // Element not present
        else
 
            // Print statement
            System.out.println("Element found at index "
                               + result);
    }
}

输出

Element found at index 3

示例 2

Java

// Java Program to Illustrate Recursive Binary Search
 
// Importing required classes
import java.util.*;
 
// Main class
class GFG {
 
    // Method 1
    // Recursive binary search
    // Returns index of x if it is present
    // in arr[l..r], else return -1
    int binarySearch(int arr[], int l, int r, int x)
    {
        // Restrict the boundary of right index
        // and the left index to prevent
        // overflow of indices
        if (r >= l && l <= arr.length - 1) {
 
            int mid = l + (r - l) / 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, l, mid - 1, x);
 
            // Else the element can only be present
            // in right subarray
            return binarySearch(arr, mid + 1, r, x);
        }
 
        // We reach here when element is not present in
        // array
        return -1;
    }
 
    // Method 2
    // Main driver method
    public static void main(String args[])
    {
 
        // Creating object of above class
        GFG ob = new GFG();
 
        // Custom input array
        int arr[] = { 2, 3, 4, 10, 40 };
 
        // Length of array
        int n = arr.length;
 
        // Custom element to be checked
        // whether present or not
        int x = 10;
 
        // Calling above method
        int result = ob.binarySearch(arr, 0, n - 1, x);
 
        // Element present
        if (result == -1)
 
            // Print statement
            System.out.println("Element not present");
 
        // Element not present
        else
 
            // Print statement
            System.out.println("Element found at index "
                               + result);
    }
}

输出

Element found at index 3