代码随想录-1 数组 刷题记录

1.理论基础

        数组是存放在连续空间上的相同类型数据的结合。

        特点：

        （1）连续存储 ->决定了插入、删除操作牵扯到移动其他元素

        （2）可以通过下标实现随机访存

数组的连续性表明了它在有序情况下在查找上的优势。

 

同时也表明了其在插入、删除上的劣势。

Java的3*4二维数组在内存中不是 3*4 的连续地址空间，而是四条连续的地址空间组成

2.关于数组的题目技巧

（1）二分查找

704.二分查找

关于二分查找，一个要明晰的核心点是，我们正在查找的范围，是不能够确定的范围。这一点可以用红蓝染色法来理解（b站up主灵茶山艾府）。

理解了这一点，就能够明白在在左闭右闭区间，以及左闭右开区间，两种方式迭代过程中，mid的值该如何变化。

（2）双指针

977.有序数组的平方

283.移动零

双指针往往能够降低一层的时间复杂度，这是因为双指针利用两个指针，在一层循环同时做了两件事情。

上面题目中，双指针有快慢指针、双向指针两种类型。

在快速排序的实现中，也有双指针的应用。

（3）滑动窗口

209.长度最小的子数组

滑动窗口也是双指针应用的一种，关注的范围是两个指针之间，意图调节两个指针调节子序列的长度，解决与子序列有关的问题。

实现滑动窗口需要考虑：

窗口内是什么？

如何移动窗口起始位置？

如何移动窗口结束位置？

在本题中，滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)暴力解法降为O(n)。

实现一：使用for循环的索引作为滑动窗口的结束位置，调节子序列起始位置：

class Solution {

    // 滑动窗口
    public int minSubArrayLen(int s, 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 >= s) {
                result = Math.min(result, right - left + 1);
                sum -= nums[left++];
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

实现二：和实现一的思路一样，只是滑动窗口的感觉更明显，维护了start和end下标：

class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        int n = nums.length;
        if (n == 0) {
            return 0;
        }
        int ans = Integer.MAX_VALUE;
        int start = 0, end = 0;
        int sum = 0;
        while (end < n) {
            sum += nums[end];
            while (sum >= s) {
                ans = Math.min(ans, end - start + 1);
                sum -= nums[start];
                start++;
            }
            end++;
        }
        return ans == Integer.MAX_VALUE ? 0 : ans;
    }
}

（4）前缀和

58.区间和

前缀和的思想是重复利用计算过的子数组之和，从而降低区间查询需要累加计算的次数。

前缀和 在涉及计算区间和的问题时非常有用！

如果，我们想统计，在vec数组上 下标 2 到下标 5 之间的累加和，那用 p[5] - p[1] 就可以了。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int n = scanner.nextInt();
        int[] vec = new int[n];
        int[] p = new int[n];

        int presum = 0;
        for (int i = 0; i < n; i++) {
            vec[i] = scanner.nextInt();
            presum += vec[i];
            p[i] = presum;
        }

        while (scanner.hasNextInt()) {
            int a = scanner.nextInt();
            int b = scanner.nextInt();

            int sum;
            if (a == 0) {
                sum = p[b];
            } else {
                sum = p[b] - p[a - 1];
            }
            System.out.println(sum);
        }

        scanner.close();
    }
}

前缀和例题：44. 开发商购买土地（第五期模拟笔试）

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int sum = 0;
        int[][] vec = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                vec[i][j] = scanner.nextInt();
                sum += vec[i][j];
            }
        }

        // 统计横向
        int[] horizontal = new int[n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                horizontal[i] += vec[i][j];
            }
        }

        // 统计纵向
        int[] vertical = new int[m];
        for (int j = 0; j < m; j++) {
            for (int i = 0; i < n; i++) {
                vertical[j] += vec[i][j];
            }
        }

        int result = Integer.MAX_VALUE;
        int horizontalCut = 0;
        for (int i = 0; i < n; i++) {
            horizontalCut += horizontal[i];
            result = Math.min(result, Math.abs(sum - 2 * horizontalCut));
        }

        int verticalCut = 0;
        for (int j = 0; j < m; j++) {
            verticalCut += vertical[j];
            result = Math.min(result, Math.abs(sum - 2 * verticalCut));
        }

        System.out.println(result);
        scanner.close();
    }
}

一道模拟题，其中使用到二分法中的左闭右开的技巧/思想：

54.螺旋矩阵

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] nums = new int[n][n];
        int startX = 0, startY = 0;  // 每一圈的起始点
        int offset = 1;
        int count = 1;  // 矩阵中需要填写的数字
        int loop = 1; // 记录当前的圈数
        int i, j; // j 代表列, i 代表行;

        while (loop <= n / 2) {

            i=startX;
            j=startY
            // 顶部
            // 左闭右开，所以判断循环结束时， j 不能等于 n - offset
            for (j = startY; j < n - offset; j++) {
                nums[i][j] = count++;
            }

            // 右列
            // 左闭右开，所以判断循环结束时， i 不能等于 n - offset
            for (i = startX; i < n - offset; i++) {
                nums[i][j] = count++;
            }

            // 底部
            // 左闭右开，所以判断循环结束时， j != startY
            for (; j > startY; j--) {
                nums[i][j] = count++;
            }

            // 左列
            // 左闭右开，所以判断循环结束时， i != startX
            for (; i > startX; i--) {
                nums[i][j] = count++;
            }
            startX++;
            startY++;
            offset++;
            loop++;
        }
        if (n % 2 == 1) { // n 为奇数时，单独处理矩阵中心的值
            nums[startX][startY] = count;
        }
        return nums;
    }
}