leetcode34、704、剑指offer 57 —— 在递增数组中查找目标值的问题（双指针法）

递增数组中查找目标值（双指针or二分查找）

1、二分查找

1.1、二分查找

原题链接
给定一个 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
 

提示：

你可以假设 nums 中的所有元素是不重复的。
n 将在 [1, 10000]之间。
nums 的每个元素都将在 [-9999, 9999]之间。

1.1.1、思路

二分查找框架

int binarySearch(int[] nums, int target) {
    int left = 0, right = ...;

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

细节问题：

• 不要出现 else，而是把所有情况用 else if 写清楚，这样可以清楚地展现所有细节。
• 计算 mid 时需要防止溢出，代码中多用 left + (right - left) / 2

1.1.2、题解

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

1.2、寻找左侧边界

int left_bound(vector<int>& nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else if (nums[mid] == target) {
            // 别返回，锁定左侧边界
            right = mid - 1;
        }
    }
    // 最后要检查 left 越界的情况
    if (left >= nums.size() || nums[left] != target)
        return -1;
    return left;
}

1.3、寻找右侧边界

int right_bound(vector<int>& nums, int target) {
    int left = 0, right = nums.size() - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else if (nums[mid] == target) {
            // 别返回，锁定右侧边界
            left = mid + 1;
        }
    }
    // 最后要检查 right 越界的情况
    if (right < 0 || nums[right] != target)
        return -1;
    return right;
}

1.4、在排序数组中查找元素的第一个和最后一个位置

原题链接
给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

你的算法时间复杂度必须是 O(log n) 级别。

如果数组中不存在目标值，返回 [-1, -1]。

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]
示例 2:

输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]

1.4.1、题解

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        if(nums.empty()) 
            return {-1,-1};
        
        int left=0;
        int right=nums.size()-1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] < target) 
            {
                left = mid + 1;
            } 
            else if (nums[mid] > target) 
            {
                right = mid - 1;
            } 
            else if (nums[mid] == target)
            {
                // 别返回，锁定左侧边界
                right = mid - 1;
            }
        }
    // 最后要检查 left 越界的情况
        if (left >= nums.size() || nums[left] != target)
            return {-1,-1};;
        int start=left;

        left=0;
        right=nums.size()-1;
        while (left <= right) 
        {
            int mid = left + (right - left) / 2;
            if (nums[mid] < target) {
                left = mid + 1;
            } else if (nums[mid] > target) {
                right = mid - 1;
            } else if (nums[mid] == target) {
                // 别返回，锁定右侧边界
                left = mid + 1;
            }
        }
    // 最后要检查 right 越界的情况
        if (right < 0 || nums[right] != target)
            return {-1,-1};
        int end=right;
        
        return {start,end};
    }
};

2、和为S的连续正数序列

原题链接

输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。

序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。

示例 1：

输入：target = 9
输出：[[2,3,4],[4,5]]
示例 2：

输入：target = 15
输出：[[1,2,3,4,5],[4,5,6],[7,8]]
 

限制：
1 <= target <= 10^5

2.1、题解

class Solution {
public:
    vector<vector<int>> findContinuousSequence(int target) {
        vector<vector<int>>res;
        if(target < 3)
            return res;
            
        int small = 1;//左指针
        int big = 2;//右指针
        while (small < (target +1)/2)
        {
            int cur = (small + big)*(big - small + 1)/2;//等差数列求和公式
            if(cur == target)
            {
                vector<int>s_sum;
                for(int i = small;i <= big;i++)
                {
                    s_sum.push_back(i);
                }
                res.push_back(s_sum);
                big++;
            }
            else if(cur < target)
                big++;
            else
                small++;
        }
        return res;
    }
};

3、和为s的两个数字

原题链接

输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[2,7] 或者 [7,2]
示例 2：

输入：nums = [10,26,30,31,47,60], target = 40
输出：[10,30] 或者 [30,10]
 

限制：

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^6

3.1、题解

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {  // 双指针
        vector<int> result;
        int sum, i = 0, j = nums.size()-1;
        while(i < j){
            sum = nums[i]+nums[j];
            if(sum==target){
                result.push_back(nums[i]);
                result.push_back(nums[j]);
                break;
            }
            if(sum>target) j--;
            else i++;
        }
        
        return result;
    }
};