我如何摆脱这个递归调用？

Question

我是递归的新手，我仍在学习它，所以如果它不好，请容忍我糟糕的逻辑。 我有这个函数，它有 5 个参数 a、b、c、x、y。 所以我本质上想要做的是从这些变量中的一个中取出一个元素并将其添加到另一个中以最终得到 x , y 。 我想自己尝试一下，我几乎已经完成了，只是我想问一下，一旦我得到“是”的答案，我是否可以摆脱这种递归调用。

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String in = sc.nextLine();
        int[] input = new int[10];
        for(int i=0; i < 10; i=i+2) {
            input[i] = Integer.parseInt(String.valueOf(in.charAt(i)));
        }
        int A = input[0];
        int B = input[2];
        int C = input[4];
        int X = input[6];
        int Y = input[8];
        persistent(A,B,C,X,Y);
    }

    private static void persistent(int a, int b, int c, int x, int y) {
        if(a == 0 || b == 0 || c == 0) {
            if((a == x && b == y) && (b == x && a == y)) {
                System.out.println("YES");
            }
            else if((b == x && c == y) || (c == x && b == y)) {
                System.out.println("YES");
            }
            else if((a == x && c == y) && (c == x && a == y)) {
                System.out.println("YES");
            }
            else {
            return;
            }
        }
        persistent(a-1,b+1,c,x,y);
        persistent(a-1,b,c+1,x,y);
        persistent(a+1,b-1,c,x,y);
        persistent(a,b-1,c+1,x,y);
        persistent(a+1,b,c-1,x,y);
        persistent(a,b+1,c-1,x,y);
    }

Answer 1

你的代码永远不会。

递归算法几乎都归结为完全相同的风格：

1. 首先，检查是否达到了某些边缘情况（通常是最简单的情况）。 在这种情况下，立即返回 - 不要递归。 通过同义反复，如果答案如此简单，您可以直接给出它而无需递归，这定义了“边缘情况”/“简单情况”。 必须至少有一种这样的情况，否则递归算法将无法工作。

2. 否则，请提供你的答案，并为您喜欢尽可能多的递归调用随意雇佣，但这些电话的每一个最后一位必须是简单的，通过的想法，它是严格更接近于简单的情况下，在1提到的定义。

3. 所有状态都通过参数传达。 通常有一个私有的辅助方法来完成实际工作，它有一堆额外的参数，而公共 API 是一个单行调用辅助函数，为这些额外的参数提供初始值。 只有当你没有这种状态时，你才能省略这个状态。

你的代码没有这样做。 有一个简单的情况，即如果 a 或 b 或 c 为 0，但您的 6 次递归调用并没有明显地趋向于简单。

修复并不明显。 您的算法无法按书面方式工作，并且如果不经过大量重新思考就无法修复。

希望以上内容对您有所帮助：您的递归调用需要以某种方式变得更简单，保证。 现在不能保证：是的，每次调用都将 3 个数字之一移近边缘情况（为 0），但没有明确的流程：如果我使用3/4/5作为参数调用您的代码，那么它与recurisve电话2/5/5 ， 2/4/6 ，等等。 第一次调用 ( 2/5/5 ) 并不能保证更接近边缘情况，因为作为其调用堆栈的一部分，它将再次执行3/4/5 。