JAVA二分查找及变形

最新推荐文章于 2023-05-11 18:57:22 发布

superdaojian

最新推荐文章于 2023-05-11 18:57:22 发布

阅读量246

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/superdaojian/article/details/78996595

本文介绍了二分查找算法的基本实现，包括迭代和递归两种方式，并展示了如何寻找特定值及其首次和末次出现的位置。通过具体示例代码，读者可以深入了解二分查找的工作原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/**
 * Created by superdaojian on 18/1/7.
 */
public class BinarySearch {

    //arr是排好序的，这里假定是升序，找到其中一个value的位置
    //-1说明没找到
    public static int binarySearch(int arr[], int value) {
        int left = 0, right = arr.length - 1, mid;
        while (left <= right) {
            mid = left + (right - left) / 2;
            if (arr[mid] == value) {
                return mid;
            } else if (arr[mid] < value) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1;
    }

    //递归版
    //arr是排好序的，这里假定是升序，找到其中一个value的位置
    //-1说明没找到
    public static int binarySearchRecur(int arr[], int value, int left, int right) {
        if (left > right) {
            return -1;
        }
        int mid = left + (right - left) / 2;
        if (arr[mid] == value) {
            return mid;
        } else if (arr[mid] < value) {
            return binarySearchRecur(arr, value, mid + 1, right);
        } else {
            return binarySearchRecur(arr, value, left, mid - 1);
        }

    }

    //arr是排好序的，这里假定是升序，最小的一个value的位置
    //-1说明没找到
    public static int binarySearchMin(int arr[], int value) {
        int left = 0, right = arr.length - 1, mid;
        while (left <= right) {
            mid = left + (right - left) / 2;
            if (arr[mid] >= value) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        if (left < 0 || left > arr.length - 1) {
            return -1;
        } else {
            return arr[left] == value ? left : -1;
        }
    }

    //递归版
    //arr是排好序的，这里假定是升序，最小的一个value的位置
    //-1说明没找到
    public static int binarySearchMinRecur(int arr[], int value, int left, int right) {
        if (left > right) {
            if (left < 0 || left > arr.length - 1) {
                return -1;
            } else {
                return arr[left] == value ? left : -1;
            }
        }
        int mid = left + (right - left) / 2;
        if (arr[mid] >= value) {
            return binarySearchMinRecur(arr, value, left, mid - 1);
        } else {
            return binarySearchMinRecur(arr, value, mid + 1, right);
        }
    }


    //arr是排好序的，这里假定是升序，最大的一个value的位置
    //-1说明没找到
    public static int binarySearchMax(int arr[], int value) {
        int left = 0, right = arr.length - 1, mid;
        while (left <= right) {
            mid = left + (right - left) / 2;
            if (arr[mid] > value) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        if (right < 0 || right > arr.length - 1) {
            return -1;
        } else {
            return arr[right] == value ? right : -1;
        }
    }

    //递归版
    //arr是排好序的，这里假定是升序，最大的一个value的位置
    //-1说明没找到
    public static int binarySearchMaxRecur(int arr[], int value, int left, int right) {
        if (left > right) {
            if (right < 0 || right > arr.length - 1) {
                return -1;
            } else {
                return arr[right] == value ? right : -1;
            }
        }
        int mid = left + (right - left) / 2;
        if (arr[mid] > value) {
            return binarySearchMaxRecur(arr, value, left, mid - 1);
        } else {
            return binarySearchMaxRecur(arr, value, mid + 1, right);
        }
    }

    public static void main(String[] args) {
        int arr[] = {1, 5, 9, 10, 10,10, 10, 10,  18, 19, 20, 20};
        System.out.println(binarySearch(arr, 10));
        System.out.println(binarySearchRecur(arr, 10, 0, 8));
        System.out.println(binarySearchMin(arr, 20));
        System.out.println(binarySearchMinRecur(arr, 22, 0, 11));

        System.out.println(binarySearchMax(arr, 20));
        System.out.println(binarySearchMaxRecur(arr, 20, 0, 11));

    }
}