何时在递归中使用 ArrayList 而不是数组

Question

所以我有这个问题。我试图编写一个程序来打印括号的所有有效可能排列，即我们可以有 3 个括号 ((()))、(()())、()()()、(())()等等

我有一个工作代码

public static void main(String[] args) {
    int number = 3; // No. of brackets
    int cn = number;
    int on = number;
    // open and closed brackets respectively
    char[] sol = new char[6];
    printSol(on, cn, sol, 0);
}

public static void printSol(int cn, int on, char[] sol, int k) {
    if (on == 0 && cn == 0) {
        System.out.println("");
        for (int i = 0; i < 6; i++) {
            System.out.print(sol[i]);
        }
    }

    else {
        if (on > 0) {
            if (cn > 0) {
                sol[k] = '(';
                printSol(on - 1, cn, sol, k + 1);
            }
        }

        if (cn > on) {
            sol[k] = ')';
            printSol(on, cn - 1, sol, k + 1);
        }
    }
}

现在的问题是我想使用 ArrayList 而不是 char 数组来执行此操作。 我尝试过，但出现错误。如果有人有任何建议，请告诉我。问这个问题的主要目的是我想知道在递归问题中我什么时候更喜欢 ArrayLists 而不是数组。

附： 我很抱歉缩进不佳，因为由于冲浪限制，我不得不输入整个程序，并且可能存在一些语法错误，但我已尽力而为。 谢谢 莫希特

Answer 1

您希望避免在递归时按值传递大型数据结构，因为它会消耗大量内存。总的来说，这是我唯一能想到的。传递对数组或 ArrayList 的引用是可以的。一般来说，我更喜欢 ArrayList。

请查看 Java 的 Stack 类来解决这个问题。

Answer 2

我认为您使用char[] 做得很好。速度很快，很中肯。

我想说您在实践中遇到的大多数递归问题都没有遵循这种模式。这是因为通常在遇到需要递归的问题时，您会在搜索树上针对一个特定 目标（树上的一个特定叶节点）执行搜索。您正在执行迭代：您正在尝试访问树上的每个叶节点，并为每个叶节点执行一个操作。

使用常见的搜索算法（如深度优先搜索），您无需在递归时准备结果，而是在找到目标后放松时准备结果。

但对于您这样做的情况，char[] 效果很好。您基本上是通过参数sol 和k 模拟堆栈（sol 保存数据，而 k 指向堆栈顶部）。正如其他人所注意到的，您可以直接使用堆栈（通过传递 Deque<Character> 实现，通常是 LinkedList）。

在我看来ArrayList 是倒退了一步。如果您要使用集合，请使用专为解决问题而设计的集合。

编辑：这是一个使用双端队列的未经测试的实现：

public static void printSol(int cn, int on, Deque<Character> sol) {
    if (on == 0 && cn == 0) {
        System.out.println("");
        for ( Iterator<Character> it = sol.descendingIterator(); it.hasNext(); ) {
            System.out.println(it.next());
        }
    }

    else {
        if (on > 0) {
            if (cn > 0) {
                sol.push('(');
                printSol(on - 1, cn, sol);
                sol.pop();
            }
        }

        if (cn > on) {
            sol.push(')');
            printSol(on, cn - 1, sol);
            sol.pop();
        }
    }
}

//...
printSol(3, 3, new ArrayDeque<Character>(6));

如您所见，变化很少。

编辑 2：对于这个特定问题，我们完全没有讨论过的一件事是StringBuilder。

StringBuilder 是一种可变的 String 类型，可让您轻松添加和删除字符。这也是解决这个问题的好方法：

public static void printSol(int cn, int on, StringBuilder sol) {
    if (on == 0 && cn == 0) {
        System.out.println(sol);
    }

    else {
        if (on > 0) {
            if (cn > 0) {
                sol.append('(');
                printSol(on - 1, cn, sol);
                sol.deleteCharAt(sol.length()-1);
            }
        }

        if (cn > on) {
            sol.append(')');
            printSol(on, cn - 1, sol);
            sol.deleteCharAt(sol.length()-1);
        }
    }
}

Answer 3

我意识到没有人（包括我自己）真正回答了您的问题。我认为您已经确信在这里使用ArrayList 是不可取的。但是如何让它发挥作用呢？

最简单的方法基本上是用它来伪造一个堆栈：

public static void printSol(int cn, int on, ArrayList<Character> sol) {
   //...
   sol.add('(');
   printSol(on - 1, cn, sol);
   sol.remove(sol.size() - 1);