二分查询-leetcode

二分查找-leetcode

/**
 * 
 * 278. First Bad Version
 * 
 * You are a product manager and currently leading a team to develop a new
 * product. Unfortunately, the latest version of your product fails the quality
 * check. Since each version is developed based on the previous version, all the
 * versions after a bad version are also bad.
 * 
 * Suppose you have n versions [1, 2, ..., n] and you want to find out the first
 * bad one, which causes all the following ones to be bad.
 * 
 * You are given an API bool isBadVersion(version) which will return whether
 * version is bad. Implement a function to find the first bad version. You
 * should minimize the number of calls to the API.
 * 
 * note: The isBadVersion API is defined in the parent class VersionControl.
 * boolean isBadVersion(int version);
 *
 */
public class Lc278 {
    /*
     * 本题利用二分查找，不同于普通的二分查找，本题是利用二分发找到最先出现的bad code，所以利用折半找到对应位置。
     * 
     * 需要注意的是常规的二分法是利用mid = (left+right)/2;如果left =
     * Integer.maxValue,right=Inter.maxValue,就会超过啦 可以用 left + （right-left） 就可以避免以上情况
     */
    public static int firstBadVersion(int n) {
        int left = 1;
        int right = n;
        while (right > left) {
            int mid = left + (right - left) / 2;
            if (isBadVersion(mid)) {
                right = mid;
            } else {
                left = left + 1;
            }
        }
        return left;
    }

    public static boolean isBadVersion(int version) {
        return  false;
    }

    public static void main(String[] args) {
        System.out.println(firstBadVersion(5));
    }
}

/**
 * Given a sorted array and a target value, return the index if the target is
 * found. If not, return the index where it would be if it were inserted in
 * order.
 * 
 * You may assume no duplicates in the array.
 * 
 *
 */
public class Lc35 {
    /**
     *标准的二分查找题目
     *
     * 
     */
    public static int searchInsert(int[] nums, int target) {
        if (nums.length == 0) {
            return 0;
        }
        int left = 0;
        int right = nums.length;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] > target) {
                right = mid;
            } else if (nums[mid] < target) {
                left = mid + 1;
            }
        }
        return ++right;
    }

    public static void main(String[] args) {
        int[] nums = { 1, 3 };
        int target = 2;
        System.out.println(searchInsert(nums, target));
    }
}

import java.util.Arrays;

/**
 * 
 * 33. Search in Rotated Sorted Array
 * 
 * Suppose an array sorted in ascending order is rotated at some pivot unknown
 * to you beforehand.
 * 
 * (i.e., [0,1,2,4,5,6,7] might become [4,5,6,7,0,1,2]).
 * 
 * You are given a target value to search. If found in the array return its
 * index, otherwise return -1.
 * 
 * You may assume no duplicate exists in the array.
 * 
 * Your algorithm's runtime complexity must be in the order of O(log n).
 *
 */
public class Lc33 {
    /**
     * 数组之间相互指向是地址指向，值改变双方都是改变
     * 
     */
    public static int search(int[] nums, int target) {
        if (nums.length == 0) {
            return -1;
        }
        // 复制到新的空间
        int temp[] = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            temp[i] = nums[i];
        }
        // 排序
        Arrays.sort(temp);

        int left = 0;
        int right = nums.length;

        // 记录目标数据在排序后数组中的位置
        int position = Integer.MAX_VALUE;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (target == temp[mid]) {
                position = mid;
                break;
            } else if (temp[mid] > target) {
                right = mid;
            } else if (temp[mid] < target) {
                left = left + 1;
            }
        }
        // 数组中无该数据
        if (position == Integer.MAX_VALUE) {
            return -1;
        }
        // 找到目标数据在数组中的位置，找到对应值在原数组的位置
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == temp[position]) {
                return i;
            }
        }
        return nums.length;

    }

    public static void main(String[] args) {
        int nums[] = { 4, 5, 6, 7, 0, 1, 2 };
        int target = 0;
        System.out.println(search(nums, target));
    }
}

/*
 * 
 * 153. Find Minimum in Rotated Sorted Array
 * 
 * 
 * Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.

(i.e.,  [0,1,2,4,5,6,7] might become  [4,5,6,7,0,1,2]).

Find the minimum element.

You may assume no duplicate exists in the array.
 */
public class Lc153 {
    /*
     * 首先对比俩端的数字，如果是左边小于右边，则无需比较，整体是升序；
     * 
     * 如果左边大于右边，如果中间位置的值大于左边，则中间值也在一组升序里面，则需让左边的边界为中间值 同理 右边也是
     */
    public static int findMin(int[] nums) {
        int left = 0;
        int right = nums.length;
        if (nums[left] < nums[right - 1]) {
            return nums[0];
        }

        while (left < right - 2) {
            int mid = left + (right - left) / 2;
            if (nums[mid] > nums[left]) {
                left = mid;
            } else if (nums[mid] < nums[left]) {
                right = mid;
            }
        }
        return nums[right];
    }

    public static void main(String[] args) {
        int[] nums = { 4, 5, 6, 7, 0, 1, 2 };
        System.out.println(findMin(nums));
    }
}

/*
 * We are playing the Guess Game. The game is as follows:

I pick a number from 1 to n. You have to guess which number I picked.

Every time you guess wrong, I'll tell you whether the number is higher or lower.

You call a pre-defined API guess(int num) which returns 3 possible results (-1, 1, or 0):
 */
public class Lc374 {
    /*
     * guess(int num)
     */
    public static int guessNumber(int n) {
        int left = 1;
        int right = n;
        while (left < right) {
            int mid = left + (right - left) / 2;
            int res = guess(mid);
            if (res == 0) {
                return mid;
            } else if (res == -1) {
                right = mid-1;
            } else if (res == 1) {
                left = mid+1;
            }
        }
        return n;
    }

    private static int guess(int num) {
        if (num < 2) {
            return -1;
        }
        if (num > 2) {
            return 1;
        }
        return 0;
    }

    public static void main(String[] args) {
        System.out.println(guessNumber(2));

    }
}