算法 -- 01 -- 关于有序向量查找的优化

1.总所周知 从1~n枚举可以查找出给定数的位置， 但是时间复杂度为O(n)；

2.二分查找优化，时间复杂度为O(1.5logn);

递推公式 ： T(n) = T(n / 2) + O(1)

这里需要思考一些问题：

1.当查找的数不在区间，该如何返回

2.当区间中存在重复元素，且所查找的数为重复元素，该如何返回。 一般是选择返回右边界

public class BinarySearchTest {
    
    public static int binarySearch(int[] a, int l, int r, int k) {
        int len = a.length;
        
        while (l < r) {
            int mid = (l + r) >> 1;
            if (k < a[mid]) {
                r = mid;
            } else if (a[mid] < k) {
                l = mid + 1;
            } else {
                return mid;
            }
        
            if (r == 0) {
                return -1;
            }
            if (l == len - 1) {
                //返回尾部
                return len;
            }
        }
        return -1;
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner((System.in));
        int n = 0;
        int[] a  = new int[20];
        //输入数组长度
        n = sc.nextInt();

        //输入数组
        for(int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }
        
        //目标值
        int k = 0;
        k = sc.nextInt();
        
        //二分查找
        int res = binarySearch(a, 0, n - 1, k);
        System.out.println(res);
    }
}

3.Fib优化，时间复杂度为O(n);

二分查找按0.5划分，Fib按黄金分割率划分 后续补上