算法训练day2| 有序数组的平方、长度最小的子数组

有序数组的平方：

自己的初步题解:

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int length = nums.size();
        vector<int> result(length , 0);  //注意此处的定义方式
        for(int i = 0 ,  j = length - 1 ; i <= j ; i++ , j-- ){   //注意此处的定义方式
            if(nums[i]*nums[i] > nums[j]*nums[j]){
                int tmp = nums[i];
                nums[i] = nums[j];
                nums[j] = tmp;
            }
            result[i] = nums[i] * nums[i];
            result[j] = nums[j] * nums[j];
        }
        sort(result.begin(),result.end());
        return result;
    }
};

后续看了答案后的修改:

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int k = nums.size() - 1;
        vector<int> result(nums.size(), 0);
        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;
    }
};

两次做题的区别在于for的定义，以及对于j--，i++的灵活使用，这样就可以避免使用sort进行二次排序。我第一次，没有sort这句话，但我没发现问题，实际上此时排出来的仍然会有中间小的情况(带入一组数就明白怎么回事了)。

核心是result[k--],双指针的应用，主要在两边大，向内侧递减的情况，注意i<=j，其原因是因为最后要给result的最后一个元素result[0]赋值，否则，其将没有值。

长度最小的子数组

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int result = INT32_MAX;
        int sum = 0; 
        int i = 0; 
        int subLength = 0; 
        for(int j = 0; j < nums.size() ; j++){
            sum += nums[j];
            while(sum >= target){
                subLength = j - i + 1;
                result = result < subLength ? result : subLength;
                sum -= nums[i++];
            }
        }
        return result == INT32_MAX ? 0 : result;
    }
};

sublength +1 的原因是，当i = j的情况下，滑动窗口的长度是1，不是0

核心是sum-=nums[i++]

二次题解：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        //这题注意是寻找连续子数组，因此应该是快慢指针
        int length = nums.size();
        int sum = 0 ;
        int i = 0;
        int returnLength = 0;
        int fanhui =  INT32_MAX;   //注意这里必须取最大值，否则在后面比较的时候，他有可能出现初次比较比对方小的情况，无法继续下去
        for(int j = 0 ; j < length ; j++ ){
            sum += nums[j] ;     //注意，这里的精髓在于利用每次的for去进行j元素的叠加
            while( sum >= target ){   //注意这里的表达式判断，题目说的是大于等于，不要漏了等号
                returnLength = j - i + 1 ; //注意这里的+1，因为j和i若是相等，长度实际是1，并非0
                sum -= nums[i++] ;  // 注意，这里的-=才是精髓      
                //注意这里的三目表达式的妙用，用来保存最小的returnLength
                fanhui = returnLength < fanhui ?  returnLength : fanhui;
            }   //这里有一个问题，就是怎么确保returnLength是最小，因为j还要继续向后滚动
        }
        return fanhui == INT32_MAX ? 0 : fanhui;
    }
};

螺旋矩阵暂时跳过