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

如何解决我如何摆脱这种递归调用？

我是递归的新手，我还在学习它，所以如果它不好，请容忍我糟糕的逻辑。我有这个函数，它有 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,y);
        persistent(a+1,b-1,y);
        persistent(a,c-1,y);
    }

解决方法

你的代码永远不会。

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

首先，检查是否达到了某些边缘情况（通常是最简单的情况）。在这种情况下，立即返回 - 不要递归。通过同义反复，如果答案如此简单，您可以直接给出它而无需递归，这定义了“边缘情况”/“简单情况”。 必须至少有一种这样的情况，否则递归算法无法工作。
否则，请提供您的答案并随意使用任意数量的递归调用，但最后一个调用必须更简单，定义为它严格更接近于 1 中提到的那个简单情况。
所有状态都通过参数传达。通常有一个私有的辅助方法来完成实际工作，它有一堆额外的参数，而公共 API 是一个单行调用辅助函数，为这些额外的参数提供初始值。只有没有这种状态才能省略这个。

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

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

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