# Werte eines Arrays addieren



## BlackSalad (23. Mai 2011)

hallo,

ich hab ne Frage zum addieren von arrays.

Wenn ich jetzt ein array hab und will alle Werte dieses arrays addieren um eine Zahl zu erhalten mit der ich rechnen kann. Wie mache ich das denn dann?


Hab schon gegooglet und das gefunden , verstehe es aber leider nicht so ganz:


```
for (int i = 0; i < array.length; i++ )
{
zaehler += array[i];
}
```

Würd mich freuen, wenn mir das jm daran erklären könnte.


----------



## Der Müde Joe (23. Mai 2011)

```
zaehler += array[i];
```

entspricht:

```
zaehler = zaehler + array[i];
```

und drum rum ne schleife.


----------



## Fu3L (23. Mai 2011)

Addiere jedes Element i des Arrays zu der Variablen zaehler, die vorher irgendwo deklariert wurde, damit sie nach dem Schleifendurchlauf auch noch lesbar ist...


----------



## BlackSalad (23. Mai 2011)

Super! Vielen Dank!!


----------



## s_1895 (27. Nov 2020)

und wenn der Algorithmus rekursiv sein muss?


----------



## s_1895 (27. Nov 2020)

und wenn der Algorithmus rekursiv sein muss?


----------



## kneitzel (27. Nov 2020)

Und wieder ein Zombi-Thread ....

Wenn Du den Thread rekursiv haben willst: Was hast Du Dir denn bisher überlegt? Was könntest Du denn da machen?


----------



## s_1895 (27. Nov 2020)

kneitzel hat gesagt.:


> Und wieder ein Zombi-Thread ....
> 
> Wenn Du den Thread rekursiv haben willst: Was hast Du Dir denn bisher überlegt? Was könntest Du denn da machen?


int [] arr = {1,2,3,4};
int sum = Arrays.stream(arr).sum();


----------



## kneitzel (27. Nov 2020)

s_1895 hat gesagt.:


> int [] arr = {1,2,3,4};
> int sum = Arrays.stream(arr).sum();


Das ist eine Stream Lösung, aber wo siehst Du eine Rekursion. Du wolltest doch eine Rekursive Lösung (unabhängig von der Sinn-Frage)....


----------



## s_1895 (27. Nov 2020)

Muss ich das mit einer If Bedingung machen ?

Ich studiere neben bei und ich hab das mit der Rekursion noch nicht richtig verstanden und durch das online Semester (zwecks Corona ) gibt auch nicht wirklich jemanden den ich fragen kann. Ich soll ein Array rekursiv aufsummieren, das ist die Aufgabe.


----------



## fhoffmann (27. Nov 2020)

Die Idee ist folgende:

```
sum({1,2,3,4} = 1 + sum({2,3,4});
sum({2,3,4}) = 2 + sum({3,4})
sum({3,4}) = 3 + sum({4})
sum({4}) = 4 + sum({})
sum({}) = 0
```


----------



## s_1895 (27. Nov 2020)

Ich habe allerdings kein gegebenes Array, und wenn ich das so mache, muss ich doch für jede Array Länge ein Code schreiben richtig?



fhoffmann hat gesagt.:


> Die Idee ist folgende:
> 
> ```
> sum({1,2,3,4} = 1 + sum({2,3,4});
> ...


----------



## kneitzel (27. Nov 2020)

Bei der Rekursion ist die Idee immer gleich:
- Du führst es immer auf f(x) = irgendwas mit f(x-1). Bei einem Array wäre es also so wie @fhoffmann es gezeigt hat: Immer ein Array mit einem Element weniger.
- Und dann hast Du eine Abbruchbedingung. Die Summe bei einem leeren Array ist 0.

Da du aber nun nicht auf einfache Art und weise immer ein um eins kleineres Array haben kannst, könntest Du das über Parameter machen, Du hast also eine Methode, die nicht nur das Array sondern auch das erste oder letzte Element als Parameter nimmt.

Du hättest also sozusagen etwas wie:


```
sum({1,2,3,...}, 0) = 1 + sum({1,2,3,4}, 1);
sum({1,2,3,...}, 1) = 1 + 2 + sum({1,2,3,4}, 2);
...
```

Und Abbruch wäre, wenn der zweite Parameter dann gleich der Länge ist ...


----------



## temi (27. Nov 2020)

Hier ein Beispiel für die rekursive Ausgabe eines Char-Arrays:

```
public static void main(String[] args) {

        char[] chars = "Hallo Welt!".toCharArray();

        print(chars, 0); // beginne bei Index 0 (= erstes Zeichen)
    }

    public static void print(char[] chars, int index) {
        if (index >= chars.length) return; // Abbruchbedingung: hör hier auf, wenn du am Ende bist

        System.out.print(chars[index]); // Mach was, hier: gib das geforderte Zeichen aus

        print(chars, index + 1); // ruf dich selbst auf, mit anderen Parametern, hier: nächster Index
    }
```


----------



## mihe7 (28. Nov 2020)

@httpdigest hattest Du nicht einmal eine Zusammenfassung bzgl. Rekursion geschrieben?


----------



## fhoffmann (28. Nov 2020)

s_1895 hat gesagt.:


> wenn ich das so mache, muss ich doch für jede Array Länge ein Code schreiben


Du hast nur eine Funktion:
- wenn das Array leer ist, gebe 0 zurück,
- ansonsten addiere das erste Elemt zur Summe des Arrays ab dem zweiten Element.

Da es in Java aber mühselig ist, ein Array ab dem zweiten Element zu erstellen (man muss hier sehr viel kopieren - in anderen Programmiersprachen (z.B Lisp) ist dies ganz natürlich), gab es hier schon einige Vorschläge, das Problem mit einem weiteren Parameter "index" zu erschlagen. Die ursprüngliche Idee bleibt aber die gleiche.


----------



## mihe7 (29. Nov 2020)

s_1895 hat gesagt.:


> ich hab das mit der Rekursion noch nicht richtig verstanden


Das Prinzip solltest Du eigentlich aus der Mathematik kennen. 

Das Produkt der ersten n natürlichen Zahlen kann man wie folgt definieren:






Das wäre eine "iterative" Definition: man hat eine Laufvariable i, die von 1 bis n läuft , so dass das Produkt 1*2*3*...*(n-1)*n entsteht.

Nun ist aber: 






und für das Produkt ganz rechts gilt offensichtlich:






Also haben wir insgesamt:






Damit hätte man fak(n) unter "Rückgriff auf sich selbst" (=> rekursiv) definiert, allerdings mit einem kleinen Problem: fak(0)=n*fak(-1) ist nicht definiert, denn -1 ist kein Element der natürlichen Zahlen. Wir müssen also dafür sorgen, dass die Rekursion definiert endet:






Und genau das kann man nun im Programm schreiben:

```
public int fak(int n) {
    if (n == 0) {
        return 1;
    }
    return n*fak(n-1);

    // oder kurz: return n == 0 ? 1 : n*fak(n-1);
}
```


----------

