java如何求一个数组的子数组

原创

mob64ca12d52440 2023-12-26 06:50:34 ©著作权

©著作权归作者所有：来自51CTO博客作者mob64ca12d52440的原创作品，请联系作者获取转载授权，否则将追究法律责任

求一个数组的子数组

在Java中，我们可以使用不同的算法和数据结构来求一个数组的子数组。子数组是指原数组的连续一部分。我们可以通过遍历原数组，并使用指针来找到所有可能的子数组。

方法一：暴力法

暴力法是最简单的方法，它通过遍历所有可能的子数组来求解。我们可以使用两个循环来遍历原数组的所有元素，以确定子数组的起始和结束位置。然后，我们可以使用另一个循环来收集子数组的元素。

public class Solution {
    public List<List<Integer>> subarrays(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();

        for (int i = 0; i < nums.length; i++) {
            for (int j = i; j < nums.length; j++) {
                List<Integer> subarray = new ArrayList<>();
                for (int k = i; k <= j; k++) {
                    subarray.add(nums[k]);
                }
                result.add(subarray);
            }
        }

        return result;
    }
}

方法二：滑动窗口法

滑动窗口法是一种更有效的方法，它通过维护一个窗口来找到子数组。我们可以定义两个指针，分别指向窗口的起始和结束位置。然后，我们可以通过向右移动结束指针来扩展窗口，或者向右移动起始指针来缩小窗口。

public class Solution {
    public List<List<Integer>> subarrays(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        int start = 0;
        int end = 0;

        while (start < nums.length) {
            if (end < start) {
                end = start;
            }
            List<Integer> subarray = new ArrayList<>();
            while (end < nums.length) {
                subarray.add(nums[end]);
                result.add(new ArrayList<>(subarray));
                end++;
            }
            subarray.clear();
            start++;
        }

        return result;
    }
}

方法三：动态规划法

动态规划法是一种更高效的方法，它通过利用已知的子问题的解来求解更大的问题。我们可以使用一个数组来保存以每个位置为结尾的子数组的和。然后，我们可以利用该数组来求解任意子数组的和。

public class Solution {
    public List<List<Integer>> subarrays(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        int[] sums = new int[nums.length];
        sums[0] = nums[0];

        for (int i = 1; i < nums.length; i++) {
            sums[i] = sums[i - 1] + nums[i];
        }

        for (int i = 0; i < nums.length; i++) {
            for (int j = i; j < nums.length; j++) {
                int sum = sums[j] - (i > 0 ? sums[i - 1] : 0);
                List<Integer> subarray = new ArrayList<>();
                for (int k = i; k <= j; k++) {
                    subarray.add(nums[k]);
                }
                result.add(subarray);
            }
        }

        return result;
    }
}

方法四：回溯法

回溯法是一种通过尝试所有可能的解决方案来求解问题的方法。我们可以使用递归来实现回溯法。在每一步，我们可以选择要添加到子数组中的下一个元素，或者选择不添加。

public class Solution {
    public List<List<Integer>> subarrays(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        backtrack(nums, 0, new ArrayList<>(), result);
        return result;
    }

    private void backtrack(int[] nums, int start, List<Integer> subarray, List<List<Integer>> result) {
        result.add(new ArrayList<>(subarray));
        
        for (int i = start; i < nums.length; i++) {
            subarray.add(nums[i]);
            backtrack(nums, i + 1, subarray, result);
            subarray.remove(subarray.size() - 1);
        }
    }
}