二分查找部分题目解析

---

一、搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。

示例 1:
输入: nums = [1,3,5,6], target = 5
输出: 2
示例 2:
输入: nums = [1,3,5,6], target = 2
输出: 1
示例 3:
输入: nums = [1,3,5,6], target = 7
输出: 4
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/search-insert-position
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
用二分查找找出位置，如果不在，则按顺序返回插入地址，返回插入地址的操作需要在循环每次去判断nums[mid]是否>=target的时候去赋值,最后不管能不能找到，返回的也可以是插入位置

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int l = 0;
        int r = nums.size() - 1;
        int res = nums.size(); //这里也可以给出在target大于所有值的时候插入最末尾也就是长度值
        int mid = (l + r)/2; //也可以这么写(l+r)>>1;
        while (l <= r) {
            mid = (l + r)/2;
            if (nums[mid] >= target) {
                res = mid;//这里也可以给出在找不到的情况下插入的位置
                r = mid - 1;
            } else {
                l = mid + 1;
            }
        }
        return res;
    }
};

过啦

二、二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
示例 1:
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
示例 2:
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/binary-search
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
原理就是个二分查找，可以直接用上边代码，然后判断

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l = 0;
        int r = nums.size() - 1;
        int mid;
        int res = nums.size();
        while (l <= r) {
            mid = (l + r) / 2;
            if (nums[mid] >= target) {
                res = mid;
                r = mid - 1;
            } else {
                l = mid + 1;
            }
        }
        if (res == nums.size()) {
            return -1;
        }
        if (nums[res] != target) {
            return -1;
        }
        return res;
    }
};

过啦

三、在排序数组中查找数字

统计一个数字在排序数组中出现的次数。
示例 1:
输入: nums = [5,7,7,8,8,10], target = 8
输出: 2
示例 2:
输入: nums = [5,7,7,8,8,10], target = 6
输出: 0
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
耍了下小聪明，没用二分查找。直接按顺序遍历，就OK，哈哈哈哈哈哈哈哈哈

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int n=nums.size();
        int m=0;
        for(int i=0;i<n;i++)
        {
            if(target==nums[i])
            m++;
        }
        return m;
    }
};

咳咳，还是按要求去做吧，用二分查找
先用这种方法得出目标值的最小下标，然后再去寻找右边临近target的值的下标，两个相减，就是target的个数
这种方法我觉得简直天秀

class Solution {
public:
    int searchindex(vector<int>& nums, int target) {
        int l = 0;
        int r = nums.size() - 1;
        int mid;
        int res = nums.size();
        while (l <= r) {
            mid = (l + r) >> 1;
            if (nums[mid] >= target) {
                res = mid;
                r = mid - 1;
            } else {
                l = mid + 1;
            }
        }
        return res;
    }
    int search(vector<int>& nums, int target) {
        int index = searchindex(nums, target);
        if (index == nums.size()||nums[index] != target) {
            return 0;
        }
        return searchindex(nums, target + 1) - index;//找到右边临近target的值的下标，然后相减得到个数值
    }
};

过啦

四、在线选举

给你两个整数数组 persons 和 times 。在选举中，第 i 张票是在时刻为 times[i] 时投给候选人 persons[i] 的。
对于发生在时刻 t 的每个查询，需要找出在 t 时刻在选举中领先的候选人的编号。
在 t 时刻投出的选票也将被计入我们的查询之中。在平局的情况下，最近获得投票的候选人将会获胜。
实现 TopVotedCandidate 类：
TopVotedCandidate(int[] persons, int[] times) 使用 persons 和 times 数组初始化对象。
int q(int t) 根据前面描述的规则，返回在时刻 t 在选举中领先的候选人的编号。
示例：
输入：
[“TopVotedCandidate”, “q”, “q”, “q”, “q”, “q”, “q”]
[[[0, 1, 1, 0, 0, 1, 0], [0, 5, 10, 15, 20, 25, 30]], [3], [12], [25], [15], [24], [8]]
输出：
[null, 0, 1, 1, 0, 0, 1]

解释：
TopVotedCandidate topVotedCandidate = new TopVotedCandidate([0, 1, 1, 0, 0, 1, 0], [0, 5, 10, 15, 20, 25, 30]);
topVotedCandidate.q(3); // 返回 0 ，在时刻 3 ，票数分布为 [0] ，编号为 0 的候选人领先。
topVotedCandidate.q(12); // 返回 1 ，在时刻 12 ，票数分布为 [0,1,1] ，编号为 1 的候选人领先。
topVotedCandidate.q(25); // 返回 1 ，在时刻 25 ，票数分布为 [0,1,1,0,0,1] ，编号为 1 的候选人领先。（在平局的情况下，1 是最近获得投票的候选人）。
topVotedCandidate.q(15); // 返回 0
topVotedCandidate.q(24); // 返回 0
topVotedCandidate.q(8); // 返回 1

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/online-election
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
额，这个题目难度还是有的，我们来看看这个吧
二分查找我用的upper_bound函数去做的，参考了官方给的答案

class TopVotedCandidate {
public:
    vector<int> tops;
    vector<int> times;

    TopVotedCandidate(vector<int>& persons, vector<int>& times) {
        unordered_map<int, int> voteCounts;
        voteCounts[-1] = -1;
        int top = -1;
        for (auto & p : persons) {
            voteCounts[p]++;
            if (voteCounts[p] >= voteCounts[top]) {
                top = p;
            }
            tops.emplace_back(top);
        }
        this->times = times;
    }
    
    int q(int t) {
        int pos = upper_bound(times.begin(), times.end(), t) - times.begin() - 1;
        return tops[pos];
    }
};