Понимание того, как метод вычисляет число в степени

Question

Я наткнулся на класс, который решает проблему экспоненты, но я не мог понять, как работает метод raiseToPower(). Это строка, которую я не понимаю: resultVal = baseVal * raiseToPower(baseVal,exponentVal-1);

На что умножается baseVal? raiseToPower(baseVal,exponentVal-1) мне не кажется выражением. Если baseVal == 2, чем raiseToPower(baseVal,exponentVal-1)?

Я знаю, как решить 2 ^ 3 в своей голове, мне трудно понять шаги, которые baseVal * raiseToPower(baseVal,exponentVal-1) предпринимает для решения проблемы. Я знаю, что exponentVal уменьшается на 1 каждый раз, когда вызывается raiseToPower(), но я до сих пор не понимаю, как оно содержит значение, которое можно умножить на baseVal.

Я понимаю, что этот рекурсивный метод ведет себя как al oop.

public class ExponentMethod {
    
   // calculates the result of raising a number to a power
   public static int raiseToPower(int baseVal, int exponentVal) {
      
      int resultVal;    // holds the answer to the exponent problem

      // sets resultVal to 1
      if (exponentVal == 0) {
         resultVal = 1;
      }

      else {
          
          // calculate math problem
         resultVal = baseVal * raiseToPower(baseVal,exponentVal-1);
      }

      // returns when exponentVal == 0
      return resultVal;
   }
   
   public static void main (String [] args) {
      int userBase;
      int userExponent;

      userBase = 2;
      userExponent = 3;
      System.out.println(userBase + "^" + userExponent + " = "
        + raiseToPower(userBase, userExponent));
   }
}

// output
2^3 = 8

Я знаю, что существует метод pow () для возведения числа в степень

Спасибо,

Answer 1

Метод использует рекурсию для повышения указанной c базы до определенной степени.

Давайте возьмем простой пример 2 ^ 2 и прогоняем код:

raiseToPower(2, 2) вызывается

resultVal = 2 * raiseToPower(2, 2 - 1) выполняется

raiseToPower(2, 1) вызывается

resultVal = 2 * raiseToPower(2, 1 - 1) выполняется

raiseToPower(2, 0) вызывается

Базовый случай достигнут, и мы возвращаем 1

Теперь мы go создаем резервную копию цепочки!

resultVal = 2 * 1 и возвращается 2

resultVal = 2 * 2 и 4 возвращается

Таким образом, конечный результат для 2 ^ 2 равен 4.

Другой способ подумать об этом - предположить, что кто-то уже дал вам ответ на 2 ^ 2, Вы можете использовать это для вычисления 2 ^ 3? Да, вы можете просто сделать 2 * 2 ^ 2!

Итак: raisePower(2,3) = 2 * raisePower(2,2)

Важно также иметь базовый случай (когда мощность равна 0, как в вашем примере выше) чтобы не нарваться на бесконечный l oop! Надеюсь, это поможет.

Answer 2

Чего вам не хватает, так это того, что это рекурсивный метод, который вызывает сам себя. Он продолжает делать это, сохраняя промежуточные результаты в стеке вызовов до тех пор, пока он не начнет возвращаться, выталкивая эти значения из стека для формирования ответа. Иногда оператор печати внутри метода может помочь вам увидеть, что происходит.

public static void main(String[] args) {
    System.out.println(raiseToPower(3,4));  
}
    
public static int raiseToPower(int baseVal, int exponentVal) {
    if (exponentVal == 0) {
       return 1;
    }
    int x = baseVal * raiseToPower(baseVal, exponentVal-1); 
    System.out.println("exponentVal = " + exponentVal + ",  + x = " + x);
    return x;
}

печатает

exponentVal = 1,  + x = 3
exponentVal = 2,  + x = 9
exponentVal = 3,  + x = 27
exponentVal = 4,  + x = 81
81

Поскольку рекурсивный вызов разворачивается, когда exponentVal == 0, вот что вы получите

x = 1;
x = x * baseVal; // x = baseVal
x = x * baseVal; // x = baseVal ^ 2
x = x * baseVal; // x = baseVal ^ 3
x = x * baseVal; // x = baseVal ^ 4
// return x or 81

Answer 3

Это называется рекурсией. Эта же функция вызывается рекурсивно с уменьшением степени каждый раз, умножается на базовое значение и добавляется к результату. Это будет работать так:

Рекурсивные вызовы

Answer 4

Давайте возьмем пример и поймем:

baseValue = 2; exponentialValue = 3;

Как мы можем вычислить pow (2,3), есть способы:

1. baseValue ^ exponentialValue ---- 2 ^ 3 = 8
2. baseValue x baseValue ^ exponentialValue-1 ---- 2x2 ^ 2 = 8