代码在return语句后继续执行答案

【问题标题】：Code continues to execute after return statement代码在return语句后继续执行
【发布时间】：2019-08-13 18:44:35
【问题描述】：

我写了一个算法，递归地计算给定数字的平方和，如果和最终等于 1，我希望它返回 true。

我验证了我计算的总和是正确的，如果给定的数字是 19，下一个将是 82，然后是 68，最后是 100，这应该返回 true。我检查了程序是否进入了if(sum==1)，它确实存在。如果我在return false; 之前打印总和，它会奇怪地以降序（1、68、82）打印结果总和，然后返回 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);
    }
    return false;
    }
}

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

【问题讨论】：

您调用isHappy(sum);，但您忽略了它返回的内容（从而使该代码完全无用）。
isHappy() 调用时将返回 true（如果数字平方和恰好为 1）或 false（否则）。在后一种情况下，它将递归调用自身，但完全没用（除了System.out.println 的副作用，我只将其作为调试信息）。我不明白你的意思。

标签： java algorithm return

【解决方案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);
    }
}

【讨论】：

大声笑好的，是的，它成功了，谢谢。我看到你把递归调用放在else 部分，但仍然不明白我是如何为if 部分写同样的东西，它没有返回true。
它基本上从 else 调用中返回值，并且有一次您将使用 0 调用函数，在这种情况下，基本情况（函数中的第一行）返回 false。您的函数只是缺少基本情况。
您的回答帮助我纠正了过去 3-4 小时的递归问题。谢谢:)

【解决方案2】：

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

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

sum != 0。调用 isHappy(82)。 返回假

sum != 0。调用 isHappy(68)。 返回假

sum != 0。调用 isHappy(100)。 返回假

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

要解决此问题，正如 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);，避免异常和/或无限循环。

【讨论】：

【解决方案3】：

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

【讨论】：

【解决方案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
    }
}

【讨论】：