Leetcode 162.153.33 二分法 C++实现

Leetcode 162. 寻找峰值

问题：峰值元素是指其值严格大于左右相邻值的元素。  给你一个整数数组 nums ，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。你可以假设 nums[-1] = nums[n] = -∞ 。  你必须实现时间复杂度为 O(log n) 的算法来解决此问题。

算法：二分法解决，如果mid指针所指元素 < 右边元素，则从左边找答案；如果mid指针所指元素 < 右边元素，则从右边找答案。

代码：

class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        int left = -1,right = nums.size() - 1;
        //优化
        if(nums.size() > 1){//nums数组中元素数量 > 1
            if(nums[0] > nums[1])   return 0;// 最左边的元素是峰值
            else if(nums[right] > nums[right - 1])  return right;// 最右边的元素是峰值
        }
        else    return 0;//nums数组中只有一个元素

        while(left + 1 < right){
            int mid = left + (right - left) / 2;
            if(nums[mid] < nums[mid + 1])  left = mid;//如果mid元素 < 右边元素，就从右边找答案
            else    right = mid;//如果mid元素 >= 右边元素，就从左边找答案
        }
        return right;
    }
};

---

Leetcode 153. 寻找旋转排序数组中的最小值

问题：已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次旋转后，得到输入数组。

例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：若旋转 4 次，则可以得到 [4,5,6,7,0,1,2] 。若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]  。注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。

给你一个元素值互不相同的数组 nums，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的最小元素。

你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

算法：二分法，和上一题类似。

代码：

class Solution {
public:
    int findMin(vector<int>& nums) {
        int left = -1,right = nums.size() - 1;
        if(right < 1)   return nums[0];//优化
        while(left + 1 < right) {
            int mid = left + (right - left) / 2;
            if(nums[mid] < nums[right]) right = mid;// mid < right元素，从左半段找
            else left = mid;// mid > right元素，从右半段找
        }
        return nums[right];
    }
};

---

Leetcode 33. 搜索旋转排序数组

问题：整数数组 nums 按升序排列，数组中的值互不相同。在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标从 0 开始计数）。例如，[0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。  

给你旋转后的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

 你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。

算法：二分法，分为两种情况，target 在 x ( 即 nums[mid] ）左侧或其他。

下面只讨论 x 在 target 右边，或者等于 target 的情况。其余情况 x 一定在 target 左边。

如果 x>nums[n−1] ，说明 x 在第一段中，那么 target 也必须在第一段中（否则 x 一定在 target 左边）且 x 必须大于等于 target 。写成代码为：

target > end && x >= target

如果 x ≤ nums[n−1]，说明 x 在第二段中（或者 nums 只有一段），那么 target 可以在第一段，也可以在第二段。
如果 target 在第一段，那么 x 一定在 target 右边。
如果 target 在第二段，那么 x 必须大于等于 target 。
写成代码为：

target > end || x >= target

根据这两种情况，去判断 x 和 target 的位置关系，从而不断地缩小 target 所在位置的范围，二分找到 target 。

代码：

class Solution {
public:
    int search(vector<int>& nums, int target) {
        // target是否在mid的左边
        auto is_left = [&](int i) -> bool{
            int x = nums[i];
            int end = nums.back();
            if(x > end) return target > end && x >= target;// 说明x在第一段中
            return target > end || x >= target;// x在第二段中或者只有一段
        };
        int left = -1,right = nums.size() - 1;
        while(left + 1 < right){// 开空间不为空
            int mid = left + (right - left) / 2;
            if(nums[mid] == target) return mid;//优化，如果mid符合直接return
            if(is_left(mid))    right = mid;// target在mid的左边，在左边找
            else    left = mid;// target不在mid的左边，在右边找
        }
        return nums[right] == target ? right : -1;
    }
};