# Mittelwert rekursiv



## pay (9. Mrz 2012)

```
import java.util.Scanner;

class mittelwertrekursiv {
  
  public static void main(String[] args) {
    
    double mittelwert = mittelwertwert();
    System.out.println(mittelwert);
  }
  public static double mittelwertwert() {
    Scanner scanner = new Scanner(System.in);
    System.out.println("Bitte geben Sie eine Zahl ein.");
    double zahl = scanner.nextInt();
    double mittelwert = zahl;
    int n = 0;
    n++;
    System.out.println("Bitte geben Sie eine 1 ein, um weiterzumachen, oder eine 0, um aufzuhören.");
    int i = scanner.nextInt();
    boolean x = i==1;
    if (!x) {
      return mittelwert;
    }
    else {
      mittelwert = (n * mittelwert + mittelwertwert()) / (n+1);
      return mittelwert;
    }
  }
}
```

Erst seit kurzem beschäftigen wir uns im Unterricht mit Rekursion. Folgende Aufgabe bearbeiten wir aktuell: Es soll rekursiv der Mittelwert einer Menge von Zahlen ausgegeben werden, deren Anzahl vom Benutzer bestimmt wird. Mein Programm funktioniert leider nicht allgemeingültig....nur für wenige Zahlen stimmten die Ergebnisse. Könntet ihr mir einen Anstoß geben bzw. mir sagen, wo sich der Fehler befindet? Danke vielmals...


----------



## pay (10. Mrz 2012)

Niemand eine Idee? Wenn ich das richtig sehe, besteht das Problem darin, dass ich zwar die Funktion immer wieder aufrufe (also den rekursiven Ansatz erfülle), der interger Wert n jedoch immer wieder auf 0 gesetzt wird und somit der Mittelwert nicht korrekt berechnet wird. Habe noch kleinere Abwandlungen ausprobiert, doch kein Versuch war bisher von Erfolg gekrönt...Bin absoluter Anfänger und würde mich über Hilfe freuen.


----------



## pro2 (10. Mrz 2012)

Also nur mal als Tipp: Du rufst immer wieder die Funktion Mittelwert auf und da machst du deine ganze Ein und Ausgabe neu.. macht das Sinn? 
Google


----------



## pay (10. Mrz 2012)

Das Problem ist, dass ich nicht genau weiß, was der Rekursionsanker sein könnte. Bei Aufgaben, wie das Maximum eines Arrays rekursiv zu bestimmen (Anzahl der Felder wird Schritt für Schritt verringert--> Rekursion), Fakultät rekursiv oder rekursive Addition ist mir der Rekursionsanker klar...bei der vorliegenden Aufgabe aber nicht...was genau ist der Anker?

Edit: Was genau "verringer" ich hier?


----------



## Final_Striker (10. Mrz 2012)

In der Regel hast du ein Array von Zahlen, welches du durchläufst und die zahlen addierst.


----------



## pay (10. Mrz 2012)

Danke final...habe mal versucht, deinen Ratschlag umzusetzen:


```
import java.util.Scanner;

class mittelwertneuneu {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    
    System.out.println("Bitte geben Sie an, wie viele Werte Sie eingeben möchten.");
    int n = scanner.nextInt();
    
    double[] array = new double[n];
    
    for (int x = 0; x < array.length; x++) {
      System.out.println("Bitte belegen Sie die Position " + x + " des Arrays mit einem Wert.");
      array[x] = scanner.nextDouble();
    }
   
    double mittelwert = mittelwertneu(array, array.length) / array.length;
    System.out.println("Der Mittelwert der eingegebenen Zahlen beträgt: " + mittelwert);
    }
  public static double mittelwertneu (double[] array, int n) {
    if (n == 0) {
      return 0;
    }
    else {
      return array[n-1] + mittelwertneu(array,n-1);
    }
    }
  }
```


Zwei Fragen: Würde diese Lösung (sofern sie denn überhaupt richtig ist) die Bedingung erfüllen, den Mittelwert rekursiv zu bestimmen? Gibt es nicht auch die Möglichkeit, sich nicht die einzelnen eingegeben Werte zu merken, sondern nur den bisherigen Durchschnitt der Werte sowie die Anzahl der Werte? Also entsprechend dieser rekursiven Definition des Mittelwertes:
Kopfrechnen: Durchschnitt rekursiv  LoBlog
Wie würde man dies umsetzen, sofern möglich? Danke bis hierhin^^


Edit: Das Problem bei obiger Lösung ist auch, dass der Benutzer bereits zur Eingabezeit wissen muss, wie viele Werte er eingeben muss...ließe sich das auch anders realisieren, sodass der Benutzer vor jeder Eingabe entscheiden kann, ob er einen weiteren Wert eingeben möchte? Dann würde jedoch das Problem auftreten, dass man die Größe eines Arrays nicht zur Verfügung hat...die Größe des Arrays müsste ja dynamisch angepasst werden, was bei Arrays ja nicht möglich ist. Hmmm^^


----------



## Gast2 (10. Mrz 2012)

> die Größe des Arrays müsste ja dynamisch angepasst werden, was bei Arrays ja nicht möglich ist.


Richtig, du könntest aber bei jedem Wert nen neues Array erstellen dass um eins größer ist oder alternativ ne Liste verwenden die du dann nach dem Einlesen in nen Array umwandelst.


```
mittelwertneu(array, n) / n;
```
Das könntest du ja auch umschreiben in:

```
mittelwertneu(array, array.length) / array.length;
```


----------



## pay (10. Mrz 2012)

Danke erstmal...^^ Mit Liste meinst du eine Kette von Objeken, die ihren Nachfolger referenzieren und eine Information enthalten, oder? Die Definition kenne ich, jedoch haben wir damit noch nicht gearbeitet und dürfen Listen ergo auch noch nicht in Programmen verwenden. Deinen anderen Hinweis mit den unterschiedlichen Listen werde ich mir nochmal durch den Kopf gehen lassen. Das Prinzip verstehe ich, jedoch muss ich bei der Implementierung doch eigentlich auch schon wissen, wie viele arrays ich als Übergabeparameter für die Funktion benötige?


----------



## Tobse (10. Mrz 2012)

Ich verstehe ehrlich nicht so ganz, wozu man da einen Rekursiven ansatz braucht. Sowas ist doch n simpler 3-Zeiler:

```
public double avg(int[] ar) {
    long sum=0;
    for (int i=0;i<ar.length;i++) sum+=ar[i];
    return sum/(double) ar.length;
}
```


----------



## pay (10. Mrz 2012)

@ Tobse: Das wäre auch die Lösung, die mir sofort in den Sinn kommen würde bzw. gekommen ist^^ Doch leider beinhaltet die Aufgabe die Forderung, den Mittelwert rekursiv zu berechnen...^^


----------



## Gast2 (10. Mrz 2012)

> Das Prinzip verstehe ich, jedoch muss ich bei der Implementierung doch eigentlich auch schon wissen, wie viele arrays ich als Übergabeparameter für die Funktion benötige?


Was meinst du damit? Du übergibst immer nur ein Array an die Methode, das kann ja ne beliebige Länge haben.



> Ich verstehe ehrlich nicht so ganz, wozu man da einen Rekursiven ansatz braucht. Sowas ist doch n simpler 3-Zeiler:


Das soll aber ne Übungsaufgabe zur Rekursion sein.


----------



## pay (10. Mrz 2012)

Ahh, okay...ich werde mal versuchen, dies umzusetzen...danke^^


----------



## Kiri (10. Mrz 2012)

Würde vielleicht auch sowas gelten? 


```
import java.util.ArrayList;
import java.util.Scanner;

public class MittelwertRekursiv {

    double count = 0.0;
    double zahl = 0.0;
    double mw = 0.0;
    double neu = 0.0;
    ArrayList<Double> list = new ArrayList<Double>(); //nur für die Ausgabe
    Scanner scan = new Scanner(System.in);
    
    public static void main(String[] args) {
        MittelwertRekursiv mr = new MittelwertRekursiv();
        System.out.println("Bitte geben Sie ihre Zahlen ein. Zum Beenden bzw. "
                + "zum Starten der Berechnung geben sie 999 ein!");
        mr.berechneMW();
        System.out.println("\nDer Mittelwert der Zahlen: ");
        for(double value : mr.list){
            System.out.println(value);
        }
        System.out.println("lautet: " + mr.mw);
    }
    
    public double berechneMW(){
        zahl = scan.nextDouble();
        while(zahl!=999){
            neu = zahl;
            list.add(neu);//nur für die Ausgabe
            count++;
            if(count <= 1.0){
                mw = neu;
                berechneMW();
                return mw;
            }else{
                mw = (((count-1) * mw ) + neu) / count;
                berechneMW();
                return mw;
            }
        }return mw;
    }
}
```

Die ArrayList ist nur dafür da, um am Ende die eingegebenen Zahlen nochmal auszugeben. Kann also auch rausgenommen werden.


----------



## pay (11. Mrz 2012)

Danke an alle...^^ Ich denke, dass ichs hinbekommen habe...schönes Restwochenende noch^^


----------

