//二分查詢各種情況編寫練習

public class BinarySearch {

//精確查詢---用遞迴實現二分查詢，精確查詢目標元素的位置,假定陣列遞增排列，且不存在重複元素
    public int bsearch1(int array[],int low,int high,int target){
        if(low > high) return -1;

        int mid = low + (high - low)/2;
        if(array[mid] > target){
            return bsearch1(array
 
,low,mid-1,target);
        }
        if(array[mid] < target){
            return bsearch1(array,mid+1,high,target);
        }
        return mid;
    }

//精確查詢---用迭代的方式實現二分查詢，精確查詢目標元素的位置,假定陣列遞增排列，且不存在重複元素
    public int bsearch2(int array[],int low,int high,int target){
        while(low <= high){
            int
 
 mid = low + (high - low)/2;
            if(array[mid] > target){
                high = mid -1;
            }
            else if(array[mid] < target){
                low = mid + 1;
            }
            else{
                return mid;
            }
        }
        return -1;
    }

//界限查詢----用二分查詢尋找上屆，正好大於目標數的那個數(嚴格界限，不包含自身)
 

    public int bsearchupperbound(int array[],int low,int high,int target){
        if(low > high || target >= array[high]){
            return -1;
        }


        while(low < high){
            int mid = low + (high - low)/2;
            if(array[mid] > target){
                high = mid;
            }
            else{
                low = mid + 1;
            }
        }
        return high;
    }

//界限查詢---用二分查詢尋找下屆，正好小於目標數的那個數(嚴格界限，不包含自身)
    public int bsearchlowerbound(int array[],int low,int high,int target){
        if(low > high || target <= array[low]){
            return -1;
        }

        while(low < high){
            int mid = (low + high + 1) / 2;     //這裡用向上取整，否則陷入死迴圈 因為low無法往上爬超過high

            if(array[mid] < target){
                low = mid;
            }
            else{
                high = mid -1;
            }
        }
        return low;
    }

//界限查詢---用二分查詢尋找上屆，正好大於等於目標數的那個數(鬆散界限，可以包含自身)
    public int bsearch5(int array[], int low,int high,int target){
        if(low > high || target > array[high]){
            return -1;
        }
        while(low < high){
            int mid = low + (high -low)/2;
            if(array[mid] >= target){
                high = mid;
            }
            else{
                low = mid + 1;
            }
        }
        return high;
    }

//界限查詢---用二分法尋找下屆，正好小於等於目標的那個數  (鬆散界限，可以包含自身)
    public int bsearch6(int array[],int low,int high,int target){
        if(low > high || target < array[low]){
            return -1;
        }
        while(low < high){
            int mid = (low + high + 1)/2;
            if(array[mid] <= target){
                low = mid;
            }
            else{
                high = mid - 1;
            }
        }
        return low;
    }
//用二分查詢找尋區域，找到目標元素出現的下標範圍，允許重複元素(先找到嚴格上屆和嚴格下屆)
    public int[] searchRange(int[] array, int low, int high,int target){
        int[] results = {-1,-1};
        if(low > high){
            return results;
        }
        int lower = bsearchlowerbound(array, 0, array.length -1, target);
        lower = lower + 1;
        if(array[lower] == target){
            results[0] = lower;
        }
        else{
            return results;
        }

        int upper = bsearchupperbound(array, 0, array.length - 1, target);
        upper = upper < 0 ? (array.length - 1) : (upper -1);

        results[1] = upper;

        return results;

    }