二分查找（Binary Search）Java - 循環，遞歸

package com.ph.search;

/**
 * 二分查找。循環和遞歸兩種方法實現。
 * <p>創建日期：2020-05-22 12:20</p>
 *
 * @author PengHao
 */
public class BinarySearch {
    /**
     * 循環實現的二分查找算法。時間複雜度爲O(log(n))，空間複雜度爲O(1)。
     *
     * @param src 待查找的數組
     * @param key 待查找的關鍵字
     * @return 如果數組中存在key，則返回key在src中的索引，如果找不到，返回-1。
     */
    public static int indexOfLoop(int[] src, int key) {
        if (src == null) {
            System.err.println("待查找數組不能爲null");
            return -1;
        } else if (src.length == 0) {
            return -1;
        }
        int left = 0, mid = 0, right = src.length - 1;
        while (left < right) {
            mid = left + (right - left >> 1);
            if (src[mid] >= key) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        return src[left] == key ? left : -1;
    }

    /**
     * 遞歸實現的二分查找算法。時間複雜度爲O(log(n))，空間複雜度爲O(1)。如果待查找數組爲null或者長度爲0，則返回-1，
     * 否則調用{@link #indexOfRecursion(int[], int, int, int)}方法
     *
     * @param src 待查找的數組
     * @param key 待查找的關鍵字
     * @return 如果在src中能找到key，則返回key在src中的索引，否則返回-1。
     * @see #indexOfRecursion(int[], int, int, int)
     */
    public static int indexOfRecursion(int[] src, int key) {
        if (src == null) {
            System.err.println("待查找數組不能爲null");
            return -1;
        } else if (src.length == 0) {
            return -1;
        }
        return indexOfRecursion(src, 0, src.length - 1, key);
    }

    /**
     * 尾遞歸實現的二分查找算法。時間複雜度爲O(log(n))，空間複雜度爲O(1)。如果區間[from, to]不存在，則返回-1。
     * 如果在數組的區間[from, to]中找到key，則返回索引。如果找不到，則遞歸調用自己並縮小區間。
     *
     * @param src 待查找的數組
     * @param key 待查找的關鍵字
     * @return 如果在src中能找到key，則返回key在src中的索引，否則返回-1。
     * @see #indexOfRecursion(int[], int)
     */
    private static int indexOfRecursion(int[] src, int from, int to, int key) {
        if (from > to) {
            return -1;
        }
        int mid = from + (to - from >> 1);
        if (src[mid] < key) {
            return indexOfRecursion(src, mid + 1, to, key);
        } else if (src[mid] > key) {
            return indexOfRecursion(src, from, mid - 1, key);
        } else {
            return mid;
        }
    }
}