die Methode Potenz (iterativ und rekursiv @ JAVA)

  • hallo :tongue1:

    Aufgabe: Programmieren Sie je eine iterative und eine rekursive Methode zur Berechnung von x^y.

    Aber mein Problem war an der ganzen Sache, dass ich nach der langen Suchaktion immernoch nicht 100% den Unterschied finde???
    Iteration ist mir klar (for, while, do/while) und eine Rekursion bedeutet, dass die Funktion sich selbst aufruft...... ODER :confused: :confused:
    Kann man bei der Rekursion auch (for, while, do/while) oder (if/else) benutzen?? :confused:

    Aber bei so eine einfache Aufgabe wie Potenz, kann man doch eine Rekursion nicht verwenden, zumindest ich hab das nicht hingekriegt :(


    iterativ:




    // javac Potenz.java
    // java Potenz x y

    rekursiv:




    // javac PotenzRekur.java
    // java PotenzRekur x y

    Danke :thumb:
    ciao :zwinker:

  • Ein Recursiver algorithmus fuer die potenz von positiven, ganzen zahlen koennte z.b so aussehen:

    Code
    public static int powerRecursive(int x, int y){
      return (y==0) ? 1 : x * powerRecursive(x, y-1); 
    }

    hier der selbe algorithmus auf mehrere zeilen aufgespalten. vielleicht ist das leserlicher:

    Code
    public static int powerRecursive2(int x, int y){
        int result = 0;
        if(y == 0){
          result = 1;
        }else{
          result = x * powerRecursive2(x, y-1); 
        }
        return result;
      }


    und hier ist ein iterativer ansatz:

    Code
    public static int powerIter(int x, int y){
        int result = x;
        for(int i=1;i<y;i++){
          result = result * x;
        }
        return result;
      }


    Aber achtung!

    Es gibt einen unterschied zwischen einer rekursiven methode und einem rekursiven algorithmus.

    eine rekursive methode ist eine methode, die sich selber aufruft. Ein rekursiver algorithmus drueckt die loesung durch sich selber aus.

    Man kann einen iterativen algorithmus auch mit hilfe einer rekursiven methode ausdruecken:

    hier druecke ich nicht das ergebnis durch sich selbst aus, sondern multipliziere die faktoren y mal, genauso wie ich es in powerIter gemacht habe. Ich habe halt nur das while konstrukt durch einen rekursiven aufruf ersetzt. der algorithmus ist aber immer noch der gleiche, also iterativ.

    interressant ist hier noch, dass der iterative ansatz weniger speicher verbraucht als der rekursive. Rekursive algorithmen sind dafuer in der regel simpler und einfacher zu lesen. Zumindest wenn man mit rekursion etwas uebung hat.

Jetzt mitmachen!

Sie haben noch kein Benutzerkonto auf unserer Seite? Registrieren Sie sich kostenlos und nehmen Sie an unserer Community teil!