力扣爆刷第86天之hot100五连刷16-20

文章目录

- - 力扣爆刷第86天之hot100五连刷16-20
  - [一、238. 除自身以外数组的乘积](#一、238. 除自身以外数组的乘积)
  - [二、41. 缺失的第一个正数](#二、41. 缺失的第一个正数)
  - [三、73. 矩阵置零](#三、73. 矩阵置零)
  - [四、54. 螺旋矩阵](#四、54. 螺旋矩阵)
  - [五、48. 旋转图像](#五、48. 旋转图像)

一、238. 除自身以外数组的乘积

题目链接：https://leetcode.cn/problems/product-of-array-except-self/description/?envType=study-plan-v2\&envId=top-100-liked

思路：求自身以外的数组的乘积，为了减少重复计算，可以使用数组记录下从左往右的乘积，再计算从右往左的乘积，然后两个乘积相乘即左右乘积相乘得到答案。

java 复制代码

class Solution {
    public int[] productExceptSelf(int[] nums) {
        int[] left = new int[nums.length];
        left[0] = 1;
        for(int i = 1; i < nums.length; i++) {
            left[i] = nums[i-1] * left[i-1];
        }
        int r = 1;
        for(int i = nums.length-2; i >= 0; i--) {
            r = r * nums[i+1];
            left[i] = left[i] * r; 
        }
        return left;
    }
}

二、41. 缺失的第一个正数

题目链接：https://leetcode.cn/problems/first-missing-positive/description/?envType=study-plan-v2\&envId=top-100-liked

思路：求缺失的第一个正整数，可以利用数组的索引，构造成哈希表，数组长度为N，如果nums中的数值都在[1, N]之中，那么缺失的第一个正数为N+1，如果不是，那么我们把所有的负数都给处理为N+1，让其不参与后续步骤，然后检查所有数值的绝对值，绝对值只要小于等于N+1，就将对应索引位置的数值改为负数，作为出现的标记，之后，只需要从头往后遍历，第一个大于零的即为缺失的第一个正整数。

java 复制代码

class Solution {
    public int firstMissingPositive(int[] nums) {
        int k = nums.length+1;
        for(int i = 0; i < nums.length; i++) {
            if(nums[i] <= 0) {
                nums[i] = k;
            }
        }
        for(int i = 0; i < nums.length; i++) {
            int t = Math.abs(nums[i]);
            if(t < k) {
                nums[t-1] = -Math.abs(nums[t-1]);
            }
        }
        for(int i = 0; i < nums.length; i++) {
            if(nums[i] > 0) {
                return i+1;
            }
        }
        return k;
    }
}

三、73. 矩阵置零

题目链接：https://leetcode.cn/problems/set-matrix-zeroes/description/?envType=study-plan-v2\&envId=top-100-liked

思路：将所有为0的坐标收集起来，遍历坐标来将坐标所在的行与列赋值为0；

java 复制代码

class Solution {
    public void setZeroes(int[][] matrix) {
        List<int[]> list = new ArrayList<>();
        for(int i = 0; i < matrix.length; i++) {
            for(int j = 0; j < matrix[0].length; j++) {
                if(matrix[i][j] == 0) {
                    list.add(new int[]{i, j});
                }
            }
        }
        for(int[] xy : list) {
            traverse(matrix, xy);
        }
    }
    void traverse(int[][] nums, int[] xy) {
        for(int i = 0; i < nums[0].length; i++) {
            nums[xy[0]][i] = 0;
        }
        for(int i = 0; i < nums.length; i++) {
            nums[i][xy[1]] = 0;
        }
    }
}

四、54. 螺旋矩阵

题目链接：https://leetcode.cn/problems/spiral-matrix/description/?envType=study-plan-v2\&envId=top-100-liked

思路：螺旋矩阵有多种做法，主要是看如何旋转，对于正方形矩阵，可以按照如此形式进行遍历，控制好边界条件，但是对于非正方形矩阵并不好处理。

1 1 2

4 5 2

4 3 3

因此我们使用一种通用螺旋矩阵的遍历方法，如下：每次都遍历到头，然后每次遍历都控制上下左右的边界。

1 1 1

4 5 2

3 3 2

java 复制代码

class Solution {
    List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> list = new ArrayList<>();
        int m = matrix.length, n = matrix[0].length;
        int up = 0, down = m-1, left = 0, right = n-1;
        while(list.size() < m*n) {
            if(up <= down) {
                for(int i = left; i <= right; i++) {
                    list.add(matrix[up][i]);
                }
                up++;
            }
            if(right >= left) {
                for(int i = up; i <= down; i++) {
                    list.add(matrix[i][right]);
                }
                right--;
            }
            if(down >= up) {
                for(int i = right; i >= left; i--) {
                    list.add(matrix[down][i]);
                }
                down--;
            }
            if(left <= right) {
                for(int i = down; i >= up; i--) {
                    list.add(matrix[i][left]);
                }
                left++;
            }
        }
        return list;
    }
}

五、48. 旋转图像

题目链接：https://leetcode.cn/problems/rotate-image/description/?envType=study-plan-v2\&envId=top-100-liked

思路：要求把图像向右旋转90度，步骤很简单，先把左下角和右上角对折，然后再按照竖直中线，左右对折即可。

java 复制代码

class Solution {
   public void rotate(int[][] matrix) {
        int len = matrix.length;
        // 先左下角和右上角对折
        for(int i = 0; i < len; i++) {
            for(int j = i; j < len; j++) {
                int temp = matrix[i][j];
                matrix[i][j] = matrix[j][i];
                matrix[j][i] = temp;
            }
        }

        // 然后再垂直方向左右对折
        for(int i = 0; i < len / 2; i++) {
            for(int j = 0; j < len; j++) {
                int temp = matrix[j][i];
                matrix[j][i] = matrix[j][len-i-1];
                matrix[j][len-i-1] = temp;
            }
        }
    }
}