DAY01 二分查找 与 双指针

 704. 二分查找 - 力扣（LeetCode）

需要注意两种边界情况下代码细节的处理，在【】区间下，右指针的最大值是有意义的，所以right=nums.size()-1，left<=right

关于中间值的确定，要防止直接使用(left+right)/2可能导致的整数溢出问题

当目标值在【left，middle】之间时，因为判断条件已经判断过nums[middle]不等于目标值，所以更新右指针right为middle-1。同理更新左指针left时为middle+1；

当两种判断条件都不满足时候，就是sums[middle]=target的时候

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left=0;
        int right=nums.size()-1;// [1,right]

        while(left<=right){

            int middle=left+(right-left)/2;

            if(nums[middle]>target){
                right=middle-1;
            }
            else if(nums[middle]<target){
                left=middle+1;           
            }
            else{
                return middle;
            }
        }
        return -1;
    }
};

 第二种情况为【  ）左闭右开，这时候右指针的最大值是无意义的，所以循环判断条件中left与right不能相等

当目标值在【left，middle）区间时，需要更新右指针right，因为right本身便是开区间不可取的点，所以将newright更新为middle，这样下次判别区间实际上就是【left，middle-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-left)/2;
            if(nums[middle]<target){
                left=middle+1;
            }
            else if(nums[middle]>target){
                right=middle;
            }
            else{
                return middle;
            }

        }
        return -1;
    }
};

 总结：似乎【】双闭区间的思考过程简单，代码也更对称。

 27. 移除元素 - 力扣（LeetCode）

 移除目标元素暴力解决方法：

第一个循环用于遍历所有元素，并判断各个元素是否为目标元素，判断为真时，使用第二个循环将目标元素后的所有元素依次向前覆盖，然后更新数组大小。

这里为什么更新i的大小呢？

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

 使用是双指针法，快指针使用for循环加速遍历所有元素，慢指针通过判断条件自增，快指针不等于目标数值时，将数值继承给慢指针（大致意思不严谨），更新慢指针值

等于时无事发生

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;

977. 有序数组的平方 - 力扣（LeetCode）

 暴力解法，平方后直接sort排序

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        for(int i=0;i<nums.size();i++){
            nums[i]*=nums[i];
        }
        sort(nums.begin(),nums.end());
        return nums;
    }
};

 因为是包含复数的递增数组，那么平方后最大值一定在左右两侧

所以想到使用双指针

左右指针依次向中间逼近，循环过程中将最大值赋给新的数组，并更新新数组下标值

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
   int k=nums.size()-1,leftIndex=0,rightIndex=nums.size()-1;
   vector<int> res(nums.size(),0);//创建一个新的数组
   while(leftIndex<=rightIndex){
    if(nums[leftIndex]*nums[leftIndex]>=nums[rightIndex]*nums[rightIndex]){
        res[k--]=nums[leftIndex]*nums[leftIndex];
        leftIndex++;
    }
    else{
        res[k--]=nums[rightIndex]*nums[rightIndex];
        rightIndex--;
    }
   }
   return res;
    }
};

总结：

第一天的题目还比较简单，思路也比较容易理解，更多需要的是反复练习，熟悉套路。