算法训练day2-977.有序数组得平方、209、59

代码随想录

977.有序数组得平方

解法一：暴力排序

思路：创建一个新数组长度等于原数组，然后遍历原数组将原数组元素平方赋值给新数组。调用sort API直接排序。

class Solution {
    public int[] sortedSquares(int[] nums) {
    // 使用java自带得数组排序API
    int[] arr = new int[nums.length];
    for(int i=0;i<nums.length;i++){
        arr[i] = nums[i]*nums[i];
    }
    Arrays.sort(arr);
    return arr;
    }
}

时间复杂度：O(n+n*logn) = O(n*logn)

也可以用堆来实现：利用最小堆得特点直接排序

class Solution {
    // 整体思路:利用java中得堆API进行排序，无需自行设计排序算法
    public int[] sortedSquares(int[] nums) {
        // 定义一个最小堆
        PriorityQueue<Integer> minHeap = new PriorityQueue<>(nums.length, new   Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });

       // 遍历数组，依次将数组元素得平方添加到堆中
       for(int i=0;i<nums.length;i++){
           minHeap.add(nums[i]*nums[i]);
       }
       //定义新数组
       //依次弹出堆顶元素添加到新数组中
       //返回新数组
       int[] newArray = new int[nums.length];
       for(int i=0;i<nums.length;i++){
           newArray[i] = minHeap.poll();
       }
       return newArray;

    }
}

时间复杂度：O(n^2)，堆排序时间复杂度为O(n)，再乘以外层循环O(n)就是O(n^2)

解法二：双指针

思路：  双指针，因为原数组有序，且有负数。平方后必然是两边大中间小，所以选择双指针

核心实现思想：一个指针从后向前扫描，另一个从前向后扫描
     比较当前元素的平方值，将大的平方值添加到新数组中
      如果左边的大，添加完之后，左边的指针向右移动一位
      如果右边的大，添加完之后，右边的指针向左移动一位
     如果左右平方值相等，则先把左边的加入，再把右边的加入，然后指针同时移动（本题可不用考虑该情况）

时间复杂度O(n)

class Solution {
    public int[] sortedSquares(int[] nums) {
     // 双指针，因为原数组有序，且有负数。平方后必然是两边大中间小，所以选择双指针
     //定义一个新数组
     int[] result  = new int[nums.length];
     // 核心实现思想：一个指针从后向前扫描，另一个从前向后扫描
     // 比较当前元素的平方值，将大的平方值添加到新数组中
     // 如果左边的大，添加完之后，左边的指针向右移动一位
     // 如果右边的大，添加完之后，右边的指针向左移动一位
     // 如果左右平方值相等，则先把左边的加入，再把右边的加入，然后指针同时移动
     int left = 0; 
     int right = nums.length-1;
     int index = nums.length-1;
     while(left <= right){ // 当左右指针相撞时，循环结束
       if(nums[left]*nums[left] > nums[right] * nums[right]){
           result[index] = nums[left]*nums[left];
           left++;
           index--;
       }else{
           result[index] = nums[right]*nums[right];
           right--;
           index--;
       }
     }
     return result;
    }
}

209.长度最小得子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

解法一：滑动窗口

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
       // 滑动窗口
        int left = 0;
        int sum = 0;
        int result = Integer.MAX_VALUE;
        for (int right = 0; right < nums.length; right++) {
            sum += nums[right];
            while (sum >= target) {
                result = Math.min(result, right - left + 1);
                sum -= nums[left++];
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;

    }
}

• 时间复杂度：O(n),因为每个元素都是被操作两次总时间复杂度为O(2n)=O(n)
• 空间复杂度：O(1)

59.螺旋矩阵II

注意每条边的处理规则保持一致，左闭右开。注意循环次数n/2.当n为奇数时，要额外处理最后一个数字。

class Solution {
    public int[][] generateMatrix(int n) {
        int loop = 0;  // 控制循环次数
        int[][] res = new int[n][n];
        int start = 0;  // 每次循环的开始点(start, start)
        int count = 1;  // 定义填充数字
        int i, j;

        while (loop++ < n / 2) { // 判断边界后，loop从1开始
            // 模拟上侧从左到右
            for (j = start; j < n - loop; j++) {
                res[start][j] = count++;
            }

            // 模拟右侧从上到下
            for (i = start; i < n - loop; i++) {
                res[i][j] = count++;
            }

            // 模拟下侧从右到左
            for (; j >= loop; j--) {
                res[i][j] = count++;
            }

            // 模拟左侧从下到上
            for (; i >= loop; i--) {
                res[i][j] = count++;
            }
            start++;
        }

        if (n % 2 == 1) {
            res[start][start] = count;
        }

        return res;
    }
}

时间复杂度O（n^2）