二分查找及其变种小结

package BinaSearch;
/**
 * @Author Kyrie
 * @Date 22:49 2019/6/8
 * @Description
 *  二分查找及其变种小结
 *        基本的二分查找
 *        查找第一个相等的元素
 *        查找最后一个相等的元素
 *        查找最接近target且大于target的数的下标（如果该数存在多个，返回第一个下标），不存在返回-1
 *        查找最后一个等于或者小于target的元素
 *        查找最后一个小于key的元素
 *        查找第一个等于或者大于target的元素
 *        查找第一个大于key的元素
 **/

public class BinSearch01 {
    
    //基本的二分查找
    public static boolean binsearch01(int[] arr, int target){
        if(arr == null)
            return false;
        int mid = -1;
        int low = 0;
        int high = arr.length - 1;
        while(low <= high){
            mid = low + ((high - low) >>> 1);
            if(arr[mid] > target){
                high = mid - 1;
            }else if(arr[mid] < target){
                low = mid + 1;
            }else
                return true;
        }
        return false;
    }

    //查找第一个相等的元素
    public static int binaSearch02(int[] arr, int target){
        int low = 0;
        int high = arr.length - 1;
        while(low <= high){
            int mid = low + ((high - low) >>> 1);
            if(arr[mid] >= target){
                high = mid - 1;
            }else if(arr[mid] < target){
                low = mid + 1;
            }
        }
        if(low < arr.length && arr[low] == target)
            return low;
        else
            return -1;
    }
    //查找最后一个相等的元素
    public static int binasearch03(int[] arr, int target){
        int low = 0;
        int high = arr.length - 1;
        while(low <= high){
            int mid = low + ((high - low) >>> 1);
            if(arr[mid] > target){
                high = mid - 1;
            }else {
                low = mid + 1;
            }
        }
        if(high >= 0 && arr[high] == target)  //确保相等
            return high;
        else
            return -1;
    }

    //查找最接近target且大于target的数的下标（如果该数存在多个，返回第一个下标），不存在返回-1
    
    public static int binaSearch04(int[] arr, int target){
        int low = 0;
        int high = arr.length - 1;
        while(low <= high){
            int mid = low + ((high - low) >>> 1);
            if(arr[mid] > target){
                high = mid - 1;
            }else{
                low = mid + 1;
            }
        }
        if(high >= 0 && arr[high] == target)
            return low;
        else
            return -1;
    }

    
    // 查找最后一个等于或者小于target的元素
    public static int binaSearch05(int[] arr, int target){
        int low = 0;
        int high = arr.length - 1;
        while(low <= high){
            int mid = low + ((high - low) >>> 1);
            if(arr[mid] > target){
                high = mid - 1;
            }else{             // <= target
                low = mid + 1;
            }
            //无需判断直接返回high,
                    // 若存在target 返回最后一个相等的元素
                    // 若不存在target,则返回第一个小于key的元素
        }
        return high;
    }


    //查找最后一个小于key的元素
    
    public static int binaSearch06(int[] arr, int target){
        int low = 0;
        int high = arr.length - 1;
        while(low <= high){
            int mid = low + ((high - low) >>> 1);
            if(arr[mid] >= target){
                high = mid - 1;
            }else{
                low = mid + 1;
            }
                // 若存在target 返回第一个相等的元素位置-1 -> high
                // 若不存在target,则返回最后一个小于key的元素 -> high
        }
        return high;
    }

    
    // 查找第一个等于或者大于target的元素
    public static int binaSearch07(int[] arr, int target){
        int low = 0;
        int high = arr.length - 1;
        while(low <= high){
            int mid = low + ((high - low) >>> 1);
            if(arr[mid] >= target){
                high = mid - 1;
            }else{
                low = mid + 1;
            }
            //无需判断直接返回low,
                // 若存在target 返回第一个相等的元素
                // 若不存在target,则返回第一个大于key的元素
        }
        return low;
    }
    
    //查找第一个大于key的元素
    public static int binaSearch08(int[] arr, int target){
        int low = 0;
        int high = arr.length - 1;
        while(low <= high){
            int mid = low + ((high - low) >>> 1);
            if(arr[mid] > target){
                high = mid - 1;
            }else{
                low = mid + 1;
            }
            // 若存在target 返回第一个相等的元素位置-1 -> high
            // 若不存在target,则返回最后一个小于key的元素 -> high
        }
        return low;
    }

    public static void main(String[] args) {
        int[] data = new int[] {8,9,12,22,23,25,25,25,25,30,33,34,45,54,56,76};
        //System.out.println(binsearch01(data, 25));
        //System.out.println(binaSearch02(data, 25));  // 5
        //System.out.println(binasearch03(data, 25));  // 8
        //System.out.println(binaSearch04(data, 25));  //
        //System.out.println(binaSearch05(data, 14));  // 
        //System.out.println(binaSearch06(data, 14));  // 3
        //System.out.println(binaSearch07(data, 25));
        System.out.println(binaSearch08(data, 33));  // 11

    }
}

• 二维有序数组的查找

import java.util.Arrays;

/**
 * @program: Aglorithm
 * @Date: ****
 * @Author: Kyrie
 * @Description:
 *          二维有序数组的查找
 *          int[][] arr = {{1,2,8,9},
 *                         {2,4,9,12},
 *                         {4,7,10,13},
 *                         {6,8,11,15},
 *                          }
 *           target = 8;
 */
public class Code11_Array2Search {

    public static int[] find(int[][] arr, int target){
        int row = 0;
        int col = arr[0].length-1;
        int cur =  0;
        while(row <= arr.length-1 && col >= 0) {
            cur = arr[row][col];
            if (cur > target) {
                col--;
                //cur = arr[row][col];
            } else if (cur < target) {
                row++;
                //cur = arr[row][col];
            } else
                return new int[]{row, col};

        }
        return null;
    }

    public static void main(String[] args) {
        int[][] arr = {
                {1,2,8,9},
                {2,4,9,12},
                {4,7,10,13},
                {6,8,11,15},
        };

        int target = 15;
        int[] arr2 = find(arr, target);
        System.out.println(Arrays.toString(arr2));
    }
}