力扣算法-Day2

977.有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：

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

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

思路：

1.暴力解决：把全部的元素先进行平方，最后排序（冒泡...）

        但是这种方法的时间复杂度为O(n^2)

2.双指针：题目给我们的是非递减顺序的整数数组，那我们可以想到平方后最大值的来源无非是两个地方（索引最小、索引最大）；

        high指针：指向数组高处；

        low指针：指向数组低处；

时间复杂度为O(n)相对于O(n^2)性能提高不少

 第一种方法：（暴力解决）

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* sortedSquares(int* nums, int numsSize, int* returnSize) {
    //平方
    for (int i = 0; i< numsSize; ++i) {
        nums[i]=nums[i]*nums[i];
    }
    //冒泡排序
    for (int i = 0 ; i<numsSize - 1; ++i) {
        for (int j = 0; j < numsSize - i - 1; j++) {
            if (nums[j] > nums[j+1]) {
                int temp = nums[j];
                nums[j] = nums[j+1];
                nums[j+1] = temp;
            }
        }
    }
    *returnSize = numsSize;
    return nums;
}

 第二种方法：（双指针）

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* sortedSquares(int* nums, int numsSize, int* returnSize) {
    //索引小处的指针
    int low = 0;
    //索引大处的指针
    int high = numsSize - 1;
    //申请一个等大容量的数组
    int* copy = (int*) malloc(sizeof(int) * numsSize);
    //循环条件：是<=而不是<
    for (int i = numsSize-1; low <= high; i--) {
        //注意分支，这里用的是绝对值判断，想不起来库函数也可以用平方
        if(abs(nums[low]) > abs(nums[high])) {
            copy[i] = nums[low] * nums[low];
            low++;
        } else {
            copy[i] = nums[high] * nums[high];
            high--;
        }
    }
    *returnSize = numsSize;
    return copy;
}

 209.长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

• 输入：s = 7, nums = [2,3,1,2,4,3]
• 输出：2
• 解释：子数组 [4,3] 是该条件下的长度最小的子数组。

提示：

• 1 <= target <= 10^9
• 1 <= nums.length <= 10^5
• 1 <= nums[i] <= 10^5

思路：

 暴力解决：采用双重循环的方式，枚举所需要的最小连续子数组

        时间复杂度太高O(n^2),提交不通过。

滑动窗口：

        也是一种双指针的应用，类似的还有快慢指针、高低指针。

        时间复杂度为O(n);

方法一：（滑动窗口——双指针） 

int minSubArrayLen(int target, int* nums, int numsSize) {
    //定义和
    int sum = 0;
    //需要len大于numsSize,因为有可能数组中所有元素和小于目标值
    int len = numsSize+1;
    int i,j;//前后指针，注意j一定是后指针，如果j为前指针则和暴力解法的逻辑无差别
    for ( i=0, j=0; j<numsSize; j++) {
        sum = sum + nums[j];
        //当sum>target时，记录最小长度,并且缩小范围
        while ( sum >= target) {
            len = len > j - i + 1 ? j - i + 1 :len;
            sum-=nums[i++];
        }
    }
    //如果len的长度大于numSize说明数组中所有元素和小于目标值
    return len < numsSize?len:0;
}

方法二：（暴力解法） 不推荐

int minSubArrayLen(int target, int* nums, int numsSize){
    //初始化最小长度为INT_MAX
    int minLength = INT_MAX;
    int sum;

    int left, right;
    for(left = 0; left < numsSize; ++left) {
        //每次遍历都清零sum，计算当前位置后和>=target的子数组的长度
        sum = 0;
        //从left开始，sum中添加元素
        for(right = left; right < numsSize; ++right) {
            sum += nums[right];
            //若加入当前元素后，和大于target，则更新minLength
            if(sum >= target) {
                int subLength = right - left + 1;
                minLength = minLength < subLength ? minLength : subLength;
            }
        }
    }
    //若minLength不为INT_MAX，则返回minLnegth
    return minLength == INT_MAX ? 0 : minLength;
}

 这一期专栏记录将我每天的刷题，希望各位的监督，也希望和各位共勉。

追光的人，终会光芒万丈！！