算法——二分法查找

1.二分法基础

#include<iostream>
#include<vector>
/*

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，
写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

时间复杂度：O(logn)，其中 n 是数组的长度。
空间复杂度：O(1)。

*/
using namespace std;
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int a, b;
        a = 0;
        b = nums.size();
        int i = (a + b) / 2;
            while (a <=b)
            {
                i = (a + b) / 2;
                if (nums.at(i) == target)
                {
                    return i;
                }

                if (nums.at(i) < target)
                {
                    a = i+1;//这个i+1
                }
                else
                {
                    b = i-1;//这个i-1
                }
                i = (a + b) / 2;
            }
            return -1;
    }
};
/*
int main() {
    vector<int> v1 = { 1,2,3,5,8,9 };
    Solution solu;
    int locatioin=solu.search(v1, 6);
    std::cout << locatioin << std::endl;
    return 0;
}
*/

2.剑指 Offer II 006. 排序数组中两个数字之和
给定一个已按照 升序排列 的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target 。

函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。numbers 的下标 从 0 开始计数 ，所以答案数组应当满足 0 <= answer[0] < answer[1] < numbers.length 。

假设数组中存在且只存在一对符合条件的数字，同时一个数字不能使用两次。

示例 1：

输入：numbers = [1,2,4,6,10], target = 8
输出：[1,3]
解释：2 与 6 之和等于目标数 8 。因此 index1 = 1, index2 = 3 。
示例 2：

输入：numbers = [2,3,4], target = 6
输出：[0,2]
示例 3：

输入：numbers = [-1,0], target = -1
输出：[0,1]

class Solution {
public:
    //递归版本二分查找
    int findx(vector<int>& numbers, int start, int end, int number)
    {
        if (start > end)
            return -1;
        int index = (start + end) / 2;
        if (numbers[index] == number)
            return index;

        return ((numbers[index]) > number) ? findx(numbers, start, index - 1, number) : findx(numbers, index + 1, end, number);


    }
    vector<int> twoSum(vector<int>& numbers, int target) {
        vector<int> res(2);

        for (int i = 0; i < numbers.size(); i++)
        {
            //注释的是递归版本二分查找
           // int loc = findx(numbers, i + 1, numbers.size()-1, target - numbers[i]);
            int start = i + 1, end = numbers.size() - 1;
            int target2 = target-numbers[i];
            //非递归二分查找
            while (start <= end)
            {
                int index = (start + end) / 2;
                if (numbers[index] == target2)
                    return { i,index };
                if (numbers[index] < target2)
                    start = index+1;
                else
                    end = index-1;
            }
            

        }
        return {0 ,0};
    }
};

方法二：双指针
对于排序好的 或者有大小关系的两个数字，增减关系的 考虑用双指针

class Solution {
public:
//双指针
    vector<int> twoSum(vector<int>& numbers, int target) {
        int start=0,end=numbers.size()-1;
        while(start<end)
        {
            if((numbers[start]+numbers[end])==target)
            return {start,end};
            else if((numbers[start]+numbers[end])<target)
             start++;
             else 
             end--;
        }

        return {-1,-1};
    }
};