代码随想录算法训练营第一天 |704. 二分查找，27. 移除元素,977.有序数组的平方,209.长度最小的子数组

1、704. 二分查找

       思路：

        对于二分查找，主要是两个定义，左闭右闭 [lift, right]、左闭右开[lift , right);

        主要还是在程序里，当在while(lift<=right)中，左闭右闭是有意义的。此时更新

        right = middle -1 因为在判断里 target已经是不等于数组下标middle对应的数。

      

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 - left) / 2);
            if(nums[middle] < target){
                left = middle + 1;
            } else if(nums[middle] > target){
                right = middle - 1;
            } else {
                return middle;
            }
        }
        return -1;
    }
};

  当while(lift<right) 此时就是左闭右开，此时lift = right就不存在了，如果   

        nums[middle] > target 则 right=middle，满足左闭右开。

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

            
        }
        return -1;
    }
};

27. 移除元素

        示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。

        1、暴力循环

直接两个for循环，但是时间复杂度是O(n²)

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;j< size;j++){
                    if(nums[j] == val){
                        nums[j-i] = nums[j];
                    }
                    i--;
                    size--;
                }
            return size;
        }
};
                        

        2、双指针

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

977.有序数组的平方

        示例 1： 输入：nums = [-4,-1,0,3,10] 输出：[0,1,9,16,100] 解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]

由于输入数组是有序的，所以最大值只会在两端。可以i指向开始，j指向最后。

定义一个 result数组，随着平方之后的数的大小决定下标k对应的值。

class Solution{
public:
    vector<int> sortedSquares(vector<int>& nums){
        vector<int> result(nums.size(),0);//定义一个和nums一样尺寸的数组，默认值为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[i] * nums[i];
                i++;
            } else {
                result[k--] = nums[j] * nums[j];
                j--;
            }
        }    
    return result;
    }
};

209.长度最小的子数组

        动态滑动窗口

        就是不断调节子数组的起始位置和终止位置

class Solution{
pulic:
    int minSUbArrayLen(int s, vector<int>& nums){
        int sum = 0;
        int length = 0;
        int result = INT32_MAX;
        int i = 0;
        for(int j = 0;j < nums,size();j++){
            sum += nums[j];
            if(sums >= s){
                length = j - i - 1;
                result = result < lengrh ? result: length;
                sum -= nums[i++];
            }
        }
    return result == INT32_MAX ? 0 : result;
    }
};
        

------------------------------------------------------------------------------------

今日总结

对于数组最大的收货就是双指针的使用，二分法的细节。