Java中的递归和While循环

我正在写一个递归程序：

公共静态列表方法（int n）

确定正数

n

是否为正数（>0）的多维数据集总数。示例：给定

n=1944

（12^3+6^3），程序将按降序返回列表

[12,6]

。如果

n

不是多维数据集的总数，则程序应返回空列表

程序应该返回以第一个元素的最高可能值开始的值，然后对其余元素遵循相同的规则。例如，当

n=1072

时，程序将返回

[10,4,2]

，而不是

[9,7]

发生递归的方法：

私有静态布尔方法（看到int n、int c、LinkedList）

其中，

c

是仍然允许使用的最高数字，

soFar

是已经看到的数字列表

我的代码涵盖了基本情况和递归，但我在继续循环时遇到了问题。通过输入，

n=1944

我的程序将返回列表

[12]

，而不是

[12,6]

    public static List<Integer> method(int n)
    {
        LinkedList<Integer> result = new LinkedList<Integer>();
        int c = (int) Math.cbrt(n);
        result.add(c);
        method(n, c, result);
        return result;
    }
    private static boolean method(int n, int c, LinkedList<Integer> seen)
    {
        LinkedList<Integer> result = new LinkedList<Integer>();
        boolean b = false;
        if (n == 0)
        {
          return true;  
        }
        else if (c == 0)
        {
            return false;
        }
        else 
        {
            int sum = 0;
            for (int i : seen)
            {
                sum += i*i*i;
            }
            while (b = false)
            {
                c = (int) Math.cbrt(n - sum);
                seen.add(c);
                method(n, c, seen);
                if (sum == n)
                {
                    result = seen;
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }
        return false;
    }

公共静态列表方法（int n）
{
LinkedList结果=新建LinkedList（）；
int c=（int）Math.cbrt（n）；
结果.添加（c）；
方法（n，c，结果）；
返回结果；
}
私有静态布尔方法（见int n、int c、LinkedList）
{
LinkedList结果=新建LinkedList（）；
布尔b=假；
如果（n==0）
{
返回true；
}
else如果（c==0）
{
返回false；
}
其他的
{
整数和=0；
for（int i:seed）
{
总和+=i*i*i；
}
while（b=false）
{
c=（int）Math.cbrt（n-sum）；
见。添加（c）；
方法（n，c，see）；
如果（总和=n）
{
结果=可见；
返回true；
}
其他的
{
返回false；
}
}
}
返回false；
}

发布的代码有很多问题。但是，您的问题是关于

公共静态列表方法（int n）

：

public static List<Integer> method(int n)  {
    LinkedList<Integer> seen = new LinkedList<>();
    method(n, 0, seen);
    return seen;
}

公共静态列表方法（int n）{
LinkedList seen=新建LinkedList（）；
方法（n，0，see）；
回头看；
}

考虑改变

私有静态布尔方法（看到int n、int c、LinkedList）

到

private静态布尔方法（int n，已看到LinkedList）

---

因为您通过

c=（int）Math.cbrt（n）重新计算
c
的值
让我们看看您的while循环：

LinkedList结果=新建LinkedList（）；
布尔b=假；
//这里省略了一些代码。
while（b=false）
{
c=（int）Math.cbrt（n-sum）；
见。添加（c）；
方法（n，c，see）；
如果（总和=n）
{
结果=可见；
返回true；
}
其他的
{
返回false；
}
}

首先，当
while
循环总是以
false
作为循环的条件时，它根本不做任何事情

无论如何，即使我们假装循环运行，无论
if
执行的分支是什么，都将到达
返回。因此，您的
while
循环根本不会循环，即使其条件已更改为始终为
true
。此外，为
b
变量指定的唯一值是
false
，它根本不用于任何用途

另外，第二个方法中的
结果
列表始终为空。并且，由于
结果=seen
指令正好在
返回
之前，这是一条无害的指令，它使
结果
变得毫无用处

另外，看看
方法（n，c，seen）呼叫。它不会对其返回值做任何操作！因此，即使它最终返回
true
，您仍然可以继续，结果将生成
false

此外，每当您向所看到的
添加值时，它将永远不会被删除。由于在每个递归方法调用中看到的
始终是相同的列表，因此一旦在其中添加了一个错误的数字，它将永远不会被删除以为其他内容让路

有了这一点，我必须得出结论，你的算法是如此破碎，必须从头重写

另外，虽然你的问题不是很清楚，但我认为找到的数字肯定都不同。否则，可以使
2=13+13
，大于1的每一个数字都可以用许多立方的和来表示（即
n=13+13+13+…
）

算法如下：


第一步是将
计数
i
的
从
cbrt（n）
降到1，尝试形成立方体

然后，将多维数据集从
n
中减去，然后递归地尝试为得到的数字找到一个多维数据集和
添加一个参数以避免重复数字，该数字比上次使用的数字小一个
形成立方体时，返回形成立方体的数字。在外部调用中，将结果添加到非空内部递归调用列表中
如果内部递归调用的结果是空列表，那么
的
的当前迭代产生了一个错误的数字，我们应该尝试下一个（如果我们有下一个）
如果
的
结束时没有形成多维数据集，则返回空列表

代码如下：

import java.util.LinkedList；
导入java.util.List；
公共班机{
公共静态列表findCubeSum（int n）{
返回findCubeSum（n，n）；
}
公共静态列表findCubeSum（int n，int