【代码随想录二刷|704.二分查找、27.移除元素、977.有序数组的平方】

704.二分查找

题目链接：704. 二分查找 - 力扣（LeetCode） 

class Solution {
public:
    int search(vector<int>& nums, int target) {
        //不用二分查找，直接求
        // for(int i=0;i<nums.size();i++){
        //     if(nums[i]==target){
        //         return i;
        //     }
        // }
        // return -1;
        int left=0;
        int right=nums.size()-1;
        while(left<=right){
           int middle=(right+left)/2;
            if(target<nums[middle]){right=middle-1;}
            else if(target>nums[middle]){
                left=middle+1;
            }
            else 
            return middle;
        }
        return -1;
    }
};

27.移除元素

题目链接：27. 移除元素 - 力扣（LeetCode）

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;
    }
};

这里的i--是因为比如现在是

【0,1,2,2,3】要删的元素是2

          i   在指向2的位置，把后面的元素往前移，数组变成

【0,1,2,3】

          i   在指向后一个2的位置，如果不i--从1开始的话，就会直接往后遍历i++，漏掉2

所以要i--;

size--当然就是移动一次就少一个元素，所以size要--；

class Solution {//双指针
public:
    int removeElement(vector<int>& nums, int val) {
       int slow=0;
       for(int fast=0;fast<nums.size();fast++){
        if(val!=nums[fast]){
            nums[slow++]=nums[fast];
        }
       }
       return slow;
    }
};

双指针感觉就是用fast指针来遍历数组，用slow 指针来更新数组，最后slow指针指向的是更新后的数组。

977.有序数组的平方

题目链接：977. 有序数组的平方 - 力扣（LeetCode）

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) {
        vector<int> result(nums.size(),0);
        int k=nums.size()-1;
        for(int i=0,j=nums.size()-1;i<=j;){
            if(nums[i]*nums[i]<nums[j]*nums[j]){
                result[k--]=nums[j]*nums[j];
                j--;
            }
            else{
                result[k--]=nums[i]*nums[i];
                i++;
            }
        }
        return result;
    }
};

感觉双指针方法就是用i从前往后遍历数组，j是从后往前遍历数组，把大的赋值给新的数组