博士后自学JAVA的第三天

使用前缀和的方式查询数组中从L到R的和

问题分析
假设有如下数组，arr = [3,5,6,2,9,-1,2]。现在需求得到从L到R位的和。为了减少计算次数，我们可以构造一个二维辅助数组或者一个一位辅助数组

1、使用二维数组构造H数组

我们使用二维数组构建一个查询表。如下：

表中的数据表示，从L(纵坐标)到R(横坐标)之和，只需要查询一次即可。

	public static int[][] createTwoDimensionHelpArr(int[] Arr) {
        int n = Arr.length;
        int[][] Help = new int[n][n];
        for (int i = 0; i < n; i++) {
            int tempSum = 0;
            for (int j = i; j < n; j++) {
                tempSum += Arr[j];
                Help[i][j] = tempSum;
            }
        }
        return Help;
    }

    public static int twoDimensionHelpArr(int[][] Help, int L, int R) {
        if (L > R) {
            return 0;
        }
        else {
            return Help[L][R];
        }
    }

    public static void main(String[] args) {
        int[] arr = {3,5,6,2,9,-1,2};
        int L = 4, R = 6;
        //得到并输出Help矩阵
        int[][] Help;
        Help = createTwoDimensionHelpArr(arr);
        for (int i = 0; i < 7; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print(Help[i][j] + "\t");
            }
            System.out.println();
        }
        //得到Help矩阵中的L行R列的值
        System.out.println("============================");
        System.out.println(twoDimensionHelpArr(Help, L, R));

    }

运行结果

3	8	14	16	25	24	26	
0	5	11	13	22	21	23	
0	0	6	8	17	16	18	
0	0	0	2	11	10	12	
0	0	0	0	9	8	10	
0	0	0	0	0	-1	1	
0	0	0	0	0	0	2	
============================
10

表示从4到10的数组为[9,-1,2]，其和为10。

2、使用一维数组构造H数组

H[i]表示从0到i的和。则我们求从L到R的和为H[R]-H[L-1]。

	public static int[] createOneDimensionHelpArr(int[] Arr) {
        int n = Arr.length;
        int[] Help = new int[n];
        int tempSum = 0;
        for (int i = 0; i < n; i++) {
            tempSum += Arr[i];
            Help[i] = tempSum;
        }
        return Help;
    }

    public static int oneDimensionHelpArr(int[] Help, int L, int R) {
        if (L > R) {
            return 0;
        }
        else if (L == 0){
            return Help[R];
        }
        else {
            return Help[R] - Help[L - 1];
        }
    }

    public static void main(String[] args) {
        int[] arr = {3,5,6,2,9,-1,2};
        int L = 4, R = 6;
        //得到并输出Help矩阵
        int[] Help;
        Help = createOneDimensionHelpArr(arr);
        for (int i = 0; i < 7; i++) {
            System.out.print(Help[i] + "\t");

        }
        System.out.println();
        //得到Help矩阵中的L行R列的值
        System.out.println("============================");
        System.out.println(oneDimensionHelpArr(Help, L, R));
    }

可以得到相同的结果

3	8	14	16	25	24	26	
============================
10

总结

在频繁查询的业务场景下，可以适当消耗空间，换取时间。
如在数据为1000的情况下，查询次数为上100000000次，则可以使用初始化二维数组，直接得到数据。
由如数据场景为1000，查询次数只有10000，则可以构建一维数组，经过少量的运算，得到数据。