二分法题目：在有序数组中A内，查找数组中的某一个元素的下标（本题是从由小到大的顺序）

package LeetCode_1.Binary_search;
//小淼的算法之路

//二分法题目：在有序数组中A内，查找数组中的某一个元素的下标（本题是从由小到大的顺序）


public class Binary_search {
    //二分查找算法版本1.0
    public static int BinarySearchBasic(int[] a, int target){
        int i = 0,j = a.length -1;//设置指针和初值
        while (i <= j){
            int m = (i + j)>>>1;//m：中间值
            if(target < a[m]){//若查找的在中间值左边（小于中间值），最大值指针j占据中间值-1的位置，在进行计算
                j = m -1;
            } else if (a[m] < target){//若查找的在中间值右边（大于中间值），最小值指针j占据中间值+1的位置，在进行计算
                i = m + 1;
            } else {
                return m;//否则就是target值与中间值相等，直接返回中间值
            }
        }
        return -1;//不存在时返回-1，因为能找到的都在数组当中，在数组中的都有一个索引值，所以能找到的输出的数组索引值不可能为-1
    }
    /*本题问题1：为什么i<=j 意味着区间未比较的元素，而不是i<j  ?
     *       答：因为i,j 它们指向的元素也会参与比较，若i<j,则参与比较的只能是i与j中间的值,若这时i与j指向的元素相同则该算法会发生错误。
     * 本题问题2：为什么int m = (i + j)>>>1;，而不是int m = (i + j) / 2;  ?
     *       答：如果使用int m = (i + j) / 2 来确定中间值的话多次循环会有问题：这与二进制的第一位是不是符号位有关（1：负，0：正）。
     *           然而int m = (i + j)>>>1 这种方式：将i+j表示成的二进制整体向右移动一位（二进制对应的十进制做/2操作）
     * */

    //二分查找算法版本2.0
    public static int BinarySearchUpgrades(int[] a, int target){
        int i = 0,j = a.length;         //第一处改动
        while (i < j){                  //第二处改动
            int m = (i + j)>>>1;
            if(target < a[m]){
                j = m;                  //第三处改动
            } else if (a[m] < target){
                i = m + 1;
            } else {
                return m;
            }
        }
        return -1;
    }

    //测试类
    public static void main(String[] args) {
        int[] a = {7,13,21,30,38,44,52,53,78,79,88,89,91,92,93,94};
        int target = 92;
        long startTime = System.nanoTime();;//开始时时间点
        int result = BinarySearchBasic(a, target);//执行的算法
        long endTime = System.nanoTime();//结束时时间点
        long elapsedTime = endTime - startTime;//算法占用时间
        if (result != -1) {
            System.out.println("二分查找法1.0版本----------"+"目标值 " + target + " 在数组中的索引是 " + result+"\n"+"算法执行时间（纳秒）: " + elapsedTime);
        } else {
            System.out.println("二分查找法1.0版本----------"+"目标值 " + target + " 未在数组中找到");
        }
        long startTime_1 = System.nanoTime();;//开始时时间点
        int result_1 = BinarySearchUpgrades(a, target);
        long endTime_1 = System.nanoTime();//结束时时间点
        long elapsedTime_1 = endTime_1 - startTime_1;//算法占用时间
        if (result_1 != -1) {
            System.out.println("二分查找法2.0版本----------"+"目标值 " + target + " 在数组中的索引是 " + result_1+"\n"+"算法执行时间（纳秒）: " + elapsedTime_1);
        } else {
            System.out.println("二分查找法2.0版本----------"+"目标值 " + target + " 未在数组中找到");
        }
    }
}

function binarySearchBasic(a, target) {
    let i = 0, j = a.length - 1; // 设置指针和初值
    while (i <= j) {
        let m = (i + j) >>> 1; // m：中间值
        if (target < a[m]) {
            // 若查找的在中间值左边（小于中间值），最大值指针j占据中间值-1的位置，在进行计算
            j = m - 1;
        } else if (a[m] < target) {
            // 若查找的在中间值右边（大于中间值），最小值指针j占据中间值+1的位置，在进行计算
            i = m + 1;
        } else {
            return m; // 否则就是target值与中间值相等，直接返回中间值
        }
    }
    return -1; // 不存在时返回-1，因为能找到的都在数组当中，在数组中的都有一个索引值，所以能找到的输出的数组索引值不可能为-1
}

function binarySearchUpgrades(a, target) {
    let i = 0, j = a.length; // 第一处改动
    while (i < j) { // 第二处改动
        let m = (i + j) >>> 1;
        if (target < a[m]) {
            j = m; // 第三处改动
        } else if (a[m] < target) {
            i = m + 1;
        } else {
            return m;
        }
    }
    return -1;
}

const a = [7, 13, 21, 30, 38, 44, 52, 53, 78, 79, 88, 89, 91, 92, 93, 94];
const target = 92;

let startTime = performance.now(); // 开始时时间点
let result = binarySearchBasic(a, target);
let endTime = performance.now(); // 结束时时间点
let elapsedTime = endTime - startTime; // 算法占用时间

if (result !== -1) {
    console.log(`二分查找法1.0版本---------- 目标值 ${target} 在数组中的索引是 ${result}\n算法执行时间（毫秒）: ${elapsedTime}`);
} else {
    console.log(`二分查找法1.0版本---------- 目标值 ${target} 未在数组中找到`);
}

let startTime1 = performance.now(); // 开始时时间点
let result1 = binarySearchUpgrades(a, target);
let endTime1 = performance.now(); // 结束时时间点
let elapsedTime1 = endTime1 - startTime1; // 算法占用时间

if (result1 !== -1) {
    console.log(`二分查找法2.0版本---------- 目标值 ${target} 在数组中的索引是 ${result1}\n算法执行时间（毫秒）: ${elapsedTime1}`);
} else {
    console.log(`二分查找法2.0版本---------- 目标值 ${target} 未在数组中找到`);
}