Как работают рекурсивные параметры?

Question

public static int exponent(int baseNum, int exp) { 
    if (exp == 0) return 1; 
    else return baseNum * exponent(baseNum, --exp); 
} 

Я не понимаю, как эти два параметра работают в этом рекурсивном методе. Возвращается ли значение baseNum, переданное экспоненте, умноженное на baseNum? Тогда второй параметр (exp) делает то же самое, пока не достигнет базового случая? Если бы вы могли помочь мне визуализировать или сломать, как это работает, это было бы здорово! Спасибо.

Answer 1

Когда вы вызываете метод в первый раз, скажем, показатель степени (10,5), это означает, что рекурсивный метод вызывается 5 раз.

Каждый раз, когда exp уменьшается на 1 перед вызовом рекурсивного метода. Параметры передаются в метод. Они являются локальными переменными, поэтому они существуют только внутри метода.

показатель (10,5) будем называть

else return 10 * exponent(10,4)

затем

else return 10 * exponent(10,3)

затем

else return 10 * exponent(10,2)

... и т.д.

до exp == 0.

Answer 2

Рекурсивный метод exponent() называет себя, если второй аргумент exp не равен 0 и использует полученный результат для дальнейшего вычисления. По каждому вызову exp уменьшается на 1, поэтому, наконец, (если изначально> 0) он соответствует состоянию терминала.

Простая диаграмма последовательности для иллюстрации:

exponent(2, 3) 
    | ----------> exponent(2, 2) 
    |     | ----------> exponent(2, 1) 
    |     |     | ----------> exponent(2, 0) 
    |     |     | <---------- returns 1 // terminal condition 
    |     | <---------- returns 2 * 1 = 2 
    | <---------- returns 2 * 2 = 4 
returns 2 * 4 = 8 

Answer 3

exponent() представляет собой способ для вычисления количества (baseNum) к мощности другого числа (exp) простым умножением числа с самим exp число раз.

Если показатель степени 0, то он вернет 1, поскольку каждое целое число до степени 0 равно 1 (за исключением самого нуля, которое по какой-либо причине не покрывается).

Скажем, мы хотим рассчитать 2^3. Метод будем называть exponent(2,3).То, что происходит следующее:

• return 2*exponent(2,2);

С exponent(2,2) это то же самое, как return 2*exponent(2,1);, мы можем вместо этого записать его в следующем виде:

• return 2*2*exponent(2,1);

exponent(2,1) - это то же, что и 2*exponent(2,0) который 2*1 (когда exp есть 0, возвращаем 1). Поэтому мы можем написать это как return 2*2*2*1;

Итак, мы хотели рассчитать 2^3, и метод вызвал себя три раза и умножил 2 с собой каждый раз и, наконец, ответил на вопрос 2*2*2*1.

Не забывайте, что 0^0 является не1. Если вы звоните exponent(0,0), вы получите 1, что не так.

Answer 4

Ниже приведен пример вызова к этому рекурсивный метод с использованием 2 и 4 для аргументов ~ (:

• показатель (2, 4)
  • => 2 * показатель степени (2, 3)
    • => 2 * показатель степени (2, 2)
      • => 2 * показатель степени (2, 1)
        • => 2 * показатель степени (2, 0) < - ехр == 0, возвращает 1, так не более рекурсивных вызовов

так работают обратно цепь:

• 2 * (1) => 2
• 2 * (2) => 4
• 2 * (4) => 8
• 2 * (8) => 16

Проблема с этим конкретным способом является то, что если вы должны были пройти в отрицательном значении для exp при первом вызове вы получите бесконечную рекурсию. Лучше проверить (exp < = 0) вместо