二分查找[非递归方式]

二分查找[ 非递归方式 ]
思路：

1. 传入数组arr 、需要查找的值 target
2. 初始化 左边界 left 、右边界 right
3. 计算出 mid 值
4. 分情况判断，循环条件 left <= right ： 左边界小于等于右边界即还没有结束
   4.1 arr[mid] == target
   4.2 arr[mid] > target
   4.3 arr[mid] < target
5. 重新计算 mid 值

public class BinarySearchNoRecur {
    
    

    public static void main(String[] args) {
    
    
        int [] arr = {
    
    1,3,8,10,11,67,100};

        System.out.println(getIndexNoRecur(arr, 8)); // 2
        System.out.println(getIndexNoRecur(arr, 100));  // 6
        System.out.println(getIndexNoRecur(arr, -8));  // -1

    }


    /**
     *  二分查找非递归方式 返回对应的下标
     *
     * @return   找不到即返回 -1
     */
    public static int getIndexNoRecur(int [] arr, int target){
    
    
        // 左边界
        int left = 0;
        // 右边界
        int right = arr.length - 1;
        int mid = (left + right) / 2;
        while(left <= right){
    
    
            if(arr[mid] == target){
    
    
                return mid;
            } else if( arr[mid] < target ){
    
    
                // 大于中间值
                left = mid + 1;
            } else {
    
    
                // 小于中间值
                right = mid - 1;
            }
            mid = (left + right) / 2;
        }
        return -1;
    }


}

---

回顾之前 二分查找 [递归方式]

    /**
     *  二分查找前提--有序数组
     */
    @Test
    public void testBinarySearch(){
    
    
        int [] arr = {
    
    1,5,8,10,45,96,96,96,100};
        System.out.println(BinarySearch(arr, 0, arr.length - 1, 96));
//        System.out.println(BinarySearch2(arr, 0, arr.length - 1, 101));

    }

    /**
     *  二分查找
     * @param arr   数组
     * @param left  左边界
     * @param right   右边界
     * @param findValue   需要查找的值
     * @return
     */
    public int BinarySearch(int [] arr, int left , int right, int findValue){
    
    
        // 判断结束条件
        if(left > right){
    
    
            return -1;
        }
        int mid = (left + right) / 2;
        int midValue = arr[mid];

        if(left <= right){
    
    
            if(midValue < findValue){
    
    
                return BinarySearch(arr, mid + 1, right, findValue);
            }else if(midValue > findValue){
    
    
                return BinarySearch(arr, left, mid - 1, findValue);
            }else {
    
    
                // 找到了
                return mid;
            }
        }
        return -1;
    }

跳转： 查找算法-Bylankerens