Question

我最近一直在研究递归，但它一直很混乱。我试图编写一个java程序，它使用递归来生成一个基数的结果到一个幂，它也有一个基数有多少指数的高度。例如，一个2的基数，其幂为3，高度为3将导致：

（（（2 ^ 3）^ 3）^ 3）

这是我（非常有缺陷）的代码：

    public static void main(String[] args) {
    System.out.println(exponentWithHeight(2, 2, 3));
}

public static int exponentWithHeight(int base, int power, int height) {
    if (power < 0 || height < 0) {
        throw new IllegalArgumentException("Check input values.");
    }
    if (power == 0) {
        return 1;
    } else {
        return (base * height * exponentWithHeight(base, power - 1, height - 1));
    }
}

我真的不确定如何获得我想要的输出;正如我所说，这对我来说真的很混乱。有人可以帮忙解释如何去做吗？

Answer 1

这是一个双重递归，无论是身高还是力量。

请注意，如果将值缓存在某处是有意义的，因为exponentWithHeight（base，power，0）将重复计算多次。

此代码的结果为256：

public static void main(String[] args) {
    System.out.println(exponentWithHeight(2, 2, 3));
}

public static int exponentWithHeight(int base, int power, int height) {
    if (power < 0 || height < 0) {
        throw new IllegalArgumentException("Invalid Input; Check power and/or height value.");
    }
    if (base == 0) {
        return 0;
    }
    if (height == 0) {
        return calcPower(base, power);
    } else {
        return exponentWithHeight(calcPower(base, power), power, height - 1);
    }
}

public static int calcPower(int base, int power) {
    if (power == 0) {
        return 1;
    }
    return base * power(base, power - 1);
}

Answer 2

这是另一个简单明了的例子，使用for循环计算功率然后使用递归计算高度

public static long exponentWithHeight(long base, long power, long height) {
            long calculatedPower;
            if (power < 0 || height < 0) {
                throw new IllegalArgumentException("Invalid Input; Check power and/or height value.");
            }
            if (power == 0) {
                return 1;
            }
            if (height > 0) {
                calculatedPower = base;
                for (int i = (int) power; i > 1; i--) {
                        calculatedPower *= base;
                }
                return exponentWithHeight(calculatedPower, power, --height);
            }

            return base;

    }

Answer 3

我们是否忘记您可以将一系列指数相乘以简化等式？

以下情况应该有效。

public class ContractsController : ApiController
{
    private readonly DatabaseContext _db = new DatabaseContext();

    [ResponseType(typeof(Contract))]
    public IHttpActionResult Get(int id)
    {
        var model = _db.Contracts.Find(id);
        if (model == null)
        {
            return NotFound();
        }

        return Ok(model);
    }
}

如何使用递归计算功率的功率？

3 个答案: