java使用循環和遞歸實現二分查找

1. 二分查找

1. 漸進時間複雜度 ：它的時間複雜度是 O(logn)。

2. 使用場景

3. 二分查找依賴的是順序表結構，簡單點說就是數組；
4. 二分查找針對的是有序數據，二分查找只能用在插入、刪除操作不頻繁；
5. 數據量太小不適合二分查找；
6. 數據量太大也不適合二分查找，二分查找的底層需要依賴數組這種數據結構，而數組爲了支持隨機訪問的特性，要求內存空間連續，對內存的要求比較苛刻。

3. 代碼實現

package com.example.Leetcode;

/**
 * 二分查找，它的時間複雜度是 O(logn)。
 * <p>
 * 1. 首先，二分查找依賴的是順序表結構，簡單點說就是數組。
 * 2. 其次，二分查找針對的是有序數據。二分查找只能用在插入、刪除操作不頻繁，
 * 3. 再次，數據量太小不適合二分查找。
 * 4. 最後，數據量太大也不適合二分查找。二分查找的底層需要依賴數組這種數據結構，
 * 而數組爲了支持隨機訪問的特性，要求內存空間連續，對內存的要求比較苛刻。
 *
 * @author xuyangyang
 */
public class Bsearch {


    /**
     * 循環實現
     *
     * @param a
     * @param value
     * @return
     */
    private static int bSearchCircle(int[] a, int value) {
        int low = 0;
        int high = a.length - 1;

        while (low <= high) {
            int mid = (high - low) / 2 + low;
            if (a[mid] > value) {
                high = mid - 1;
            } else if (a[mid] < value) {
                low = mid + 1;
            } else {
                return mid;
            }
        }
        return -1;
    }

    /**
     * 遞歸實現
     *
     * @param a
     * @param value
     * @return
     */
    private static int bSearchRecursion(int[] a, int value) {

        return bSearchRecursion(a, 0, a.length - 1, 19);
    }

    private static int bSearchRecursion(int[] a, int low, int high, int value) {
        if (low > high) {
            return -1;
        }

        int mid = (high - low) / 2 + low;
        if (a[mid] == value) {
            return mid;
        } else if (a[mid] > value) {
            return bSearchRecursion(a, low, mid - 1, value);
        } else {
            return bSearchRecursion(a, mid + 1, high, value);
        }
    }


    public static void main(String[] args) {
        int[] a = {8, 11, 19, 23, 27, 33, 45, 55, 67, 98};
        int binary = bSearchCircle(a, 19);
        int binary1 = bSearchRecursion(a, 19);
        System.out.println(binary);
        System.out.println(binary1);
    }


}