返回矩阵形式的数组子集[JAVA]_Java_Algorithm_Recursion

返回矩阵形式的数组子集[JAVA]

java algorithm recursion

返回矩阵形式的数组子集[JAVA],java,algorithm,recursion,Java,Algorithm,Recursion,给定一个整数数组（长度为n），查找并返回输入数组的所有子集。所以我已经解决了这个问题，但我不确定这里工作的基本概念这是正确的解决方案 public static int[][] subsets(int input[]) { return subsets(input,0); } private static int[][] subsets(int input[], int index){ if(index == in

给定一个整数数组（长度为n），查找并返回输入数组的所有子集。所以我已经解决了这个问题，但我不确定这里工作的基本概念

这是正确的解决方案

public static int[][] subsets(int input[]) {
              
        return subsets(input,0);
    }
    private static int[][] subsets(int input[], int index){
        if(index == input.length){
            int[][] a = new int[1][0];
            return a;
        }
        
        int[][] smallAns = subsets(input,index+1);
        int[][] ans = new int[2*(smallAns.length)][];
        
        for(int i = 0 ; i < smallAns.length ; ++i){
            
                ans[i] = smallAns[i];
            
        }
        for(int i = 0 ; i < smallAns.length ; ++i){
            ans[i+smallAns.length] = new int[smallAns[i].length+1];
        }
        
        for(int i = 0 ; i < smallAns.length ; ++i){
            for(int j = 0 ; j < ans[i+smallAns.length].length ; ++j){
                if(j == 0){
                    ans[i+smallAns.length][j] = input[index];
                }
                else{
                    ans[i+smallAns.length][j] = smallAns[i][j-1];
                }
            }
        }
        
        return ans;
    }

publicstaticint[]子集（int-input[]）{
返回子集（输入，0）；
}
私有静态int[][]子集（int输入[]，int索引）{
if（index==input.length）{
int[]a=新的int[1][0]；
返回a；
}
int[][]smallAns=子集（输入，索引+1）；
int[][]ans=新的int[2*（smallAns.length）][]；
对于（int i=0；i


这是我最初的解决方案：
    public static int[][] subsets(int input[]) {
              
        return subsets(input,0);
    }
    private static int[][] subsets(int input[], int index){
        if(index == input.length){
            int[][] a = new int[1][1];
            return a;
        }
        
        int[][] smallAns = subsets(input,index+1);
        int[][] ans = new int[2*(smallAns.length)][];
        
        for(int i = 0 ; i < smallAns.length ; ++i){
            
                ans[i] = smallAns[i];
            
        }
        for(int i = 0 ; i < smallAns.length ; ++i){
            ans[i+smallAns.length] = new int[smallAns[i].length+1];
        }
        
        for(int i = 0 ; i < smallAns.length ; ++i){
            for(int j = 0 ; j < ans[i+smallAns.length].length ; ++j){
                if(j == 0){
                    ans[i+smallAns.length][j] = input[index];
                }
                else{
                    ans[i+smallAns.length][j] = smallAns[i][j-1];
                }
            }
        }
        
        return ans;
    }

publicstaticint[]子集（int-input[]）{
返回子集（输入，0）；
}
私有静态int[][]子集（int输入[]，int索引）{
if（index==input.length）{
int[]a=新的int[1][1]；
返回a；
}
int[][]smallAns=子集（输入，索引+1）；
int[][]ans=新的int[2*（smallAns.length）][]；
对于（int i=0；i

我的原始代码（第二个错误代码）在所有子集的末尾添加了0。这样地

开头给出的正确代码解决了这个问题。这两个代码之间的唯一区别是，第一个基本情况返回1X1的矩阵（错误的），第二个基本情况返回1X0的矩阵（正确的）。但我很好奇在基本情况下返回1X0矩阵。有人能解释一下，当我试图访问列的长度等时，如何不抛出NullPointerException吗
if(index == input.length){
            int[][] a = new int[1][1];
            return a;
}

使用二维数组（数组数组数组）初始化变量a
，也就是说，使用一行一列的矩阵。由于a[0][0]
未分配任何值，因此为int数据类型0
提供了一个默认值
变量a
应使用长度为0的数组数组进行初始化
int[][] a = new int[1][0];

一个1 x 0的矩阵与一个1 x 1的矩阵没有太大区别。在这两种情况下，a.length==1
以及在这两种情况下，a[0]
都是对int[]的有效的非空引用。因此，在这两种情况下，都可以安全地使用a[0].length
来询问列数：不出所料，1x1的答案是1，1x0的答案是0。只是不要尝试查看1x0矩阵上的[0][0]
是什么：您将获得ArrayIndexOutofBounds异常：0
@KevinAnderson感谢你的洞察力现在我明白了。因此，代码是这样工作的，它接受递归的结果（smallAns（第一种情况下为1X0矩阵））复制该结果，并向递归结果的每个条目添加一个数字，并将它们合并到一个更大的矩阵中。我的疑问是，当1X0矩阵的条目不存在时，在条目开始处添加选定的数字意味着什么。为什么它不包含索引或空指针异常。我问题中的第一个代码正在工作，我只是不知道具体如何工作。谢谢。想想当你复制任何长度的数组A时会发生什么；1） 设置计数器j=0
；2） 如果j>=a.length
停止；3） 将a[j]
复制到其目的地；4） 增量j（++j
）；然后返回到步骤2。如果数组的长度为1，则只需在j==a.length
之前点击步骤3一次即可。现在，如果a.length==0
，会发生什么？1） 设置计数j=0；2） 如果j>=a.length
停止j==0
，a.length==0
，因此已经j>=a.length
。循环从未到达步骤（3），您甚至从未尝试访问a[0]
，因此没有ArrayIndexOutOfBoundsException
。