Question

我编写了一种算法，该算法以递归方式计算给定数字位数的平方和，如果总和等于1，我希望它返回true。

我验证我正确地计算了总和，如果给定的数字为19，则下一个数字将为82，然后是68，最后是100，该数字应返回true。我检查了程序是否进入if(sum==1)内，并且可以。如果我在return false;之前打印总和，那么在返回false之前，它会以降序（1，68，82）的顺序打印结果总和。

class Solution {
    public boolean isHappy(int n) {
    int sum =0;
    int digit =0;
    while (n>0) {
        digit =n%10;
        sum=sum+digit*digit;
        n=n/10;
        System.out.println(sum);
    }
    if(sum==1){
        return true;
    }
    else{
        isHappy(sum);
    }
    return false;
    }
}

我的代码有什么问题？为什么总和为1后它不停止并且必须返回true？

Answer 1

不返回返回值isHappy(sum)可能是问题。看看这是否按预期工作：

class Solution {
    public boolean isHappy(int n) {
        if (n == 0) return false;

        int digit, sum = 0;

        while (n > 0) {
            digit = n % 10;
            sum += digit * digit;
            n /= 10;
            System.out.println(sum);
        }

        if(sum == 1) return true;
        else return isHappy(sum);
    }
}

Answer 2

return false将在最终调用堆栈中执行，因为从isHappy（sum）返回的值将被忽略。

Answer 3

您必须返回递归调用的值。

这将是您调用isHappy(19)时的堆栈：

sum！=0。调用isHappy（82）。 返回假

sum！=0。调用isHappy（68）。 返回假

sum！=0。调用isHappy（100）。 返回假

sum ==0。返回true：这并不意味着您的方法将返回true。堆栈中某处的递归调用返回了它，但是您的方法中没有预期到它。相反，您只需在再次调用return false后才将方法告诉isHappy()。

要解决此问题，正如tripathiakshit也提到的那样，您需要返回递归调用的值：

class Solution {
    public boolean isHappy(int n) {
        int sum =0;
        int digit =0;
        while (n>0) {
            digit =n%10;
            sum=sum+digit*digit;
            n=n/10;
            System.out.println(sum);
        }
        if(sum==1) {
            return true;
        }
        else {
            return isHappy(sum);
        }
    }
}

我还建议您采取一些安全措施以防止堆栈溢出。您应该检查是否存在您的方法永远找不到满意的结果的情况。您可以简单地创建一个基本案例来防止这种情况：

class Solution {
    public boolean isHappy(int n, int callCount) {
        if(callCount > 10) return false; // Stopping recursion if we exceed 10 calls
        int sum = 0;
        int digit = 0;
        while (n > 0) {
            digit = n % 10;
            sum = sum + digit * digit;
            n = n/10;
            System.out.println(sum);
        }
        if(sum == 1) {
            return true;
        }
        else {
            callCount++;
            return isHappy(sum, callCount);
        }
    }
}

然后，您可以舒适地调用isHappy(19, 0);，以防出现异常和/或无限循环。

Answer 4

isHappy（100）实际上返回true。你可以试试

但是，isHappy（82）和isHappy（68）将返回false，因为您从不使用递归调用中的值。您只需计算并返回false

    class Solution {
    public boolean isHappy(int n) {
    int sum =0;
    int digit =0;
    while (n>0) {
        digit =n%10;
        sum=sum+digit*digit;
        n=n/10;
        System.out.println(sum);
    }
    if(sum==1){
        return true;
    }
    else{
        isHappy(sum);  -- the recursive call's value is unused
    }
    return false;      -- you return false regardless of the computed value
    }
}

要使其正常工作，您要做的唯一更改是：

class Solution {
    public boolean isHappy(int n) {
    int sum =0;
    int digit =0;
    while (n>0) {
        digit =n%10;
        sum=sum+digit*digit;
        n=n/10;
        System.out.println(sum);
    }
    if(sum==1){
        return true;
    }
    return isHappy(sum);  -- Here
    }
}

返回语句后代码继续执行

4 个答案: