代码随想录算法训练营day 1 | Leetcode 704，35，34，27，26，283，997

Leetcode 704 二分查找

看到题的第一想法是暴力求解，从0到n-1遍历，结果正确：

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

然后看到二分法，二分法应用的前提是顺序排列且没有重复元素， 首先是左闭右闭的二分法：

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

然后是左闭右开的二分法，二分法的关键是区间的设置：

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

区间的开闭影响了while()终止条件和左右指针的移动（加减一还是否），这取决于元素是否在区间内。此外，还学习了两条代码

int middle = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2
int middle = left + ((right - left) >> 1);// 位运算

left和right在int的最大值内，但是left+right可能会溢出，且位运算更快。 

拓展练习：

Leetcode 35 搜索插入位置：

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

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

首先讨论查找值和数组的关系，分别是：1）在数组值域外；2）在数组值域内，但没有这个元素；3）在数组值域内且存在元素。使用两个二分查找分别查找左右边界。和普通的二分查找相比，普通的二分查找在没有重复元素时第一次找到target就退出循环，但是找边界在第一次找到之后仍需要继续移动指针，找左边界时，要移动右指针，直至离开target范围。

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int n = nums.size() - 1;
        int rightBorder = getRightBorder(nums, target);
        int leftBorder = getLeftBorder(nums, target);
        if(leftBorder == -2 || rightBorder == -2) return {-1, -1};
        if(rightBorder - leftBorder > 1) return {leftBorder + 1, rightBorder - 1};
        return {-1, -1};
    }
private:
    int getLeftBorder(vector<int>& nums, int target){
        int left = 0;
        int right = nums.size() - 1;
        int leftBorder = -2;
        while(left <= right){
            int middle = left + (right - left) / 2;
            if (nums[middle] >= target){
                right = middle -1;
                leftBorder = right;
            }
            else{
                left = middle + 1;
            }
        }
        return leftBorder;
    }

    int getRightBorder(vector<int>& nums, int target){
        int left = 0;
        int right = nums.size() - 1;
        int rightBorder = -2;
        while(left <= right){
            int middle = left + (right - left) / 2;
            if (nums[middle] <= target){
                left = middle + 1;
                rightBorder = left;
            }
            else{
                right = middle - 1;
            }
        }
        return rightBorder;
    }

};

Leetcode 27 移除元素

看到之后的第一反应是一个指针left指向待处理的元素，另一个right指向数组末尾，如果元素需要被删除就用right覆盖left，right前移，如果不需要就left前移：

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int left = 0;
        int right = nums.size() - 1;
        while(left <= right){
            if(nums[left] == val){
                nums[left] = nums[right];
                right --;
            }
            else{
                left ++;
            }
        }
        return left;
    }
};

看了代码随想录的思路后，重写了快慢指针的双指针，slow指向新数组的下标，fast指向遍历旧数组的元素，slow保存下fast所指的不等于val的元素。

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slowIndex = 0;
        for(int fastIndex = 0; fastIndex < nums.size(); fastIndex++){
            if(nums[fastIndex] != val){
                nums[slowIndex] = nums[fastIndex];
                slowIndex++;
            }
        }
        return slowIndex;
    }
};

拓展练习：

Leetcode 26 删除有序数组重复项

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int slowIndex = 0;
        for(int fastIndex = 1; fastIndex < nums.size(); fastIndex++){
            if(nums[fastIndex] != nums[slowIndex]){
                slowIndex++;
                nums[slowIndex] = nums[fastIndex];
            }
        }
        return slowIndex+1;
    }
};

Leetcode 283 移动零

和27一样，最后把slowIndex之后的元素全部置为零。

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int slowIndex = 0;
        for(int fastIndex = 0; fastIndex < nums.size(); fastIndex++){
            if(nums[fastIndex] != 0){
                nums[slowIndex] = nums[fastIndex];
                slowIndex++;
            }
        }
        for(; slowIndex < nums.size(); slowIndex++){
            nums[slowIndex] = 0;
        }
    }
};

Leecode 977 有序数组的平方和

第一想法是要用双指针，想到如果能到找到正负数的分界线，就可以左右两边排序填入新数组，但是要遍历多次，然后逆向思维想到两端的最大，于是双指针指向两端，判断大小移动指针填入数组：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int left = 0;
        int right = nums.size() - 1;
        int i = nums.size() - 1;
        vector<int> squaredNums(nums.size());
        while (left <= right) {
            if (abs(nums[left]) <= abs(nums[right])) {
                squaredNums[i]=nums[right] * nums[right];
                right--;
            } else {
                squaredNums[i]=nums[left] * nums[left];
                left++;
            }
            i--;
        }
        return squaredNums;
    }
};