LeetCode刷题——算法入门第三天

“前情回顾”：
LeetCode刷题——算法入门第一天
LeetCode刷题——算法入门第二天
经过昨天的学习我们学习了双指针，而今天我们将继续巩固双指针并复习二分查找。

显然是双指针问题，我一开始的思路是设立两指针分别指向起始点和终点，并通过循环里的判断语句来更新指针。

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int i=0;
        int j=nums.size()-1;
        while(i<j){
            if(nums[i]==0&&nums[j]!=0){
                swap(nums[i],nums[j]);
                j--;
                int temp=j;
                while(temp>i){
                    swap(nums[i],nums[temp]);
                    temp--;
               }
            }
            else if(nums[i]==0&&nums[j]==0){
                j--;
            }
            else{
                i++;
            }
        }
    }
};

由于中间交换元素时需要内置for循环故效率不高，勉强通过
于是研究官方题解：

public:
    void moveZeroes(vector<int>& nums) {
        int n = nums.size(), left = 0, right = 0;
        while (right < n) {
            if (nums[right]) {
                swap(nums[left], nums[right]);
                left++;
            }
            right++;
        }
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/move-zeroes/solution/yi-dong-ling-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
在这里插入代码片

发现可以通过快慢指针的方式解决该问题，拓展类双指针问题的思路。
第二题我首先想到了哈希表，只需要查询目标值减去较大值能否在哈希表中找到较小值即可。

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
       vector<int>a(2,-1);
       map<int,int>b;
       for(int i=0;i<numbers.size();i++){
          if(b.count(target-numbers[i])>0){
              a[0]=b[target-numbers[i]]+1;
              a[1]=i+1;
              break;
          }
          b[numbers[i]]=i;
       }
       return a;
    }
};

该题题解较多，以下为二分查找：

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        for (int i = 0; i < numbers.length; ++i) {
            int low = i + 1, high = numbers.length - 1;
            while (low <= high) {
                int mid = (high - low) / 2 + low;
                if (numbers[mid] == target - numbers[i]) {
                    return new int[]{i + 1, mid + 1};
                } else if (numbers[mid] > target - numbers[i]) {
                    high = mid - 1;
                } else {
                    low = mid + 1;
                }
            }
        }
        return new int[]{-1, -1};
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/two-sum-ii-input-array-is-sorted/solution/liang-shu-zhi-he-ii-shu-ru-you-xu-shu-zu-by-leet-2/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

其实与我用哈希表的方法类似，固定一个值找另一个值，区别在于此处固定的是最小值而非最大值。
双指针法：

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int low = 0, high = numbers.length - 1;
        while (low < high) {
            int sum = numbers[low] + numbers[high];
            if (sum == target) {
                return new int[]{low + 1, high + 1};
            } else if (sum < target) {
                ++low;
            } else {
                --high;
            }
        }
        return new int[]{-1, -1};
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/two-sum-ii-input-array-is-sorted/solution/liang-shu-zhi-he-ii-shu-ru-you-xu-shu-zu-by-leet-2/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

从两端向中间逐渐缩小区间直到找到目标值。