hot100 | 五、普通数组

1-leetcode53. 最大子数组和

注意：××

1. 第二次写了还是写错了，忘记了递推的关系

    public int maxSubArray(int[] nums) {
        int n = nums.length;;
        int[] dp = new int[n+1];

        // base case
        dp[0] = 0;
        int res = Integer.MIN_VALUE;
        for (int i = 1; i < dp.length; i++) {
            dp[i] = Math.max(dp[i-1] + nums[i-1], nums[i-1]);
            res = Math.max(res, dp[i]);
        }
        return res;
    }

2-leetcode56. 合并区间

注意：×

1. 注意思路，先排序，然后对比
2. 注意lamda表达式的写法，以及下面两张截图的内容

感觉这两个才是这一题的考点

    public int[][] merge(int[][] intervals) {
        int n = intervals.length;
        if (n < 2){
            return intervals;
        }
        LinkedList<int[]> res = new LinkedList<int[]>();
        Arrays.sort(intervals, (a,b) ->{return a[0] - b[0];});

        res.add(intervals[0]);
        for (int i = 1; i < intervals.length; i++) {
            int[] currArray = intervals[i];
            int[] pastArray = res.getLast();

            if (currArray[0] <= pastArray[1]){
                pastArray[1] = Math.max(pastArray[1], currArray[1]);
            }else {
                res.add(currArray);
            }
        }
        return res.toArray(new int[0][0]);
    }

3-leetcode189. 轮转数组

注意：×

1. 要不就是暴力，要不就是下面截图中的方法，感觉属于技巧题
   

    public void rotate(int[] nums, int k) {
        k = k % nums.length;
        reverse(nums, 0, nums.length - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, nums.length - 1);
    }

    private void reverse(int[] nums, int start, int end) {
        int temp = 0;
        while (start < end){
            temp = nums[start];
            nums[start] = nums[end];
            nums[end] = temp;
            start++;
            end--;
        }
    }

4-leetcode238. 除自身以外数组的乘积

注意：×

1. 乘积 = 当前数左边的乘积 * 当前数右边的乘积

    public int[] productExceptSelf(int[] nums) {
        int n = nums.length;
        int[] res = new int[n];

        int k = 1;
        for (int i = 0; i < nums.length; i++) {
            res[i] = k;
            k = k * nums[i];
        }

        k = 1;
        for (int i = nums.length - 1; i >= 0; i--) {
            res[i] = res[i] * k;
            k = k * nums[i];
        }
        return res;
    }

5-leetcode41. 缺失的第一个正数

注意：×

1. 怪不得是一个困难题，首先思路部分：先把负数全部给值为n+1因为取不到这个值
2. 然后关键的地方在于，将当前这个数，取绝对值(因为可能在之前被别的值赋值成了负数)，将这个绝对值下标减一的下标位置的数字变成负数
3. 一定一定要注意，数组中的内容是可以重复的，也就是存在[1,1]这种案例让你原本取值改了负数又被你自己改了正数
4. 因此需要在改负数的时候，直接对原来位置的数字取绝对值，然后取负数

    public int firstMissingPositive(int[] nums) {
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            if (nums[i] <= 0) {
                nums[i] = n + 1;
            }
        }

        for (int i = 0; i < n; i++) {
            if (Math.abs(nums[i]) <= n) {
                nums[Math.abs(nums[i]) - 1] = -Math.abs(nums[Math.abs(nums[i]) - 1]);
            }
        }

        for (int i = 0; i < n; i++) {
            if (nums[i] > 0) {
                return i + 1;
            }
        }
        return n + 1;
    }