# Array rekursiv teilen und aufsummieren



## Guest (5. Jul 2007)

folegende aufgabe soll ich lösen:

Schreiben Sie eine weitere Methode, die das Array im Attribut aufsummiert, allerdings
auf rekursive Art. Verwenden Sie dazu eine weitere Hilfsmethode
mit zwei Parametern, die den linken und rechten Index des aufzusummierenden Bereichs
angibt. Diese Methode soll, sofern der spezifizierte Bereich aus mehr als einer
Zahl besteht, den Bereich halbieren und rekursiv jeweils die Summe der beiden Hälften
berechnen, diese zusammenzahlen und die Summe zurückgeben!

das heißt quasi

```
public static float sum2 ( float[] array ) {
		
		if (array.length == 1 ) {
			return array[0];
			}
			else {
```
jetzt muss ich hier die methode sum2 wieder aufrufen, und die soll das array teilen und die beiden arrays aufsummieren oder? 
wie kann ich ein array ohne system.arraycopy teilen?


----------



## SlaterB (5. Jul 2007)

> Verwenden Sie dazu eine weitere Hilfsmethode mit zwei Parametern, die den linken und rechten Index des aufzusummierenden Bereichs angibt.

du sollst das Array nicht kopieren, sondern so wie es ist überall durchreichen,
mit den Indexen gibts du an, welcher Teil des Arrays gerade betrachtet wird


----------



## Leroy42 (5. Jul 2007)

... und zwar so:

```
public static float sum2 ( float[] array ) { 
       
      if (array.length == 1 ) { 
         return array[0]; 
         } 
         else {
            return sum2(array, 0, array.length()-1);
        }
}
```


----------



## Guest (5. Jul 2007)

sorry  mein fehler.... gehört noch zur aufgabe! das is die rekursive art nach der ich das machen soll!

....das array in 2 hälften aufzuteilen diese einzeln zu summieren und die beiden Ergebnisse aufzuaddieren. Das Aufsummieren der beiden Halften
kann dann wieder rekursiv durch weiteres Aufteilen und Zusammenzahlen geschehen.

das gehört noch dazu...
ich soll das array wenn es nicht der länge 1 entspricht immer in 2 teile teilen, die aufsummieren und den linken und den rechten bereich angeben.... also das array so lange teilen bis es nur noch teile der länge 1 hat.... so hab ich das verstanden!!
oder versteh ich das falsch....


----------



## SlaterB (5. Jul 2007)

wenn du das Array teilen würdest, wozu dann "linken und rechten Index als Parameter übergeben"? 
die wären dann ja bestensfalls immer 0 und array-length()-1,
schlimmstenfalls Indexe aus dem Originalarray und noch weniger zu gebrauchen,

und außerdem wäre der Aufwand gigantisch hoch, zig bis tausende Arrays zu erzeugen, je nach Größe des Ursprungsarrays,
macht keinen Sinn

auf logischer Ebene stimmt die Aussage natürlich, 
jeder Operationsaufruf summiert nur einen Teil des Arrays


----------



## Guest (5. Jul 2007)

leider muss ich das aber so machen.... hab nachgefragt.... muss das array immer teilen so wie es hier steht!!!
aber leider bekomm ich die rekursion nicht hin!!!


----------



## Leroy42 (5. Jul 2007)

Manno, das "Teilen" ist metaphorisch zu verstehen.

Durch Übergabe von je zwei Indizes (Anfang und Ende des Arrays)
teilst du schon gewissermaßen das Array.

Nimm einfach meine Methodensignatur und versuche daraus
was zu basteln.


----------



## Guest (6. Jul 2007)

> Schreiben Sie eine weitere Methode, die das Array im Attribut aufsummiert, allerdings
> auf die oben beschriebene rekursive Art. Verwenden Sie dazu eine weitere Hilfsmethode
> mit zwei Parametern, die den linken und rechten Index des aufzusummierenden Bereichs
> angibt. Diese Methode soll, sofern der spezifizierte Bereich aus mehr als einer
> ...




heißt doch:

methode1. array in 2 teile teilen, und diese dann aufsummieren!
und zwar durch so langes teilen des arrays bis die teilarrays 1 lang sind und diese dann aufsummieren...
das ganze dann mit der hilfsmethode

hilfsmethode:

soll jeweils den startwert der beiden teilarray wiedergeben! - falls das teilarray länger als 1 ist soll dieser wieder geteilt und rekursiv aufsummiert werden!


quasi einmal rekursiv teilen und in der hilfsmethode rekusiv ausummieren...

da ist doch das teilen nicht metaphorisch oder? da muss ich das doch echt teilen, und zwar auf rek. art bis die teilarrays neu noch die länge 1 haben und diese dann aufsummieren!

oder nicht?


----------



## SlaterB (6. Jul 2007)

wie jetzt, zuletzt schriebst du noch, du hättest 'nachgefragt'

die Aufgabe an sich sagt nix direkt darüber aus, was du machen sollt,
wenn man sie wörtlich nimmt kann man es so machen

den allgemeinen Erfahrungen bei solchen Formulierungen, 
dem extrem richtungsweisenden Hinweis "zwei Parametern, die den linken und rechten Index des aufzusummierenden Bereichs",
und dem gesunden Menschenverstand (Berechnungsaufwand, Programmieraufwand, Nutzen) nach
ist die Sache eindeutig: nicht teilen

wie schon X-MAL GESAGT! 
noch mal von mir jedenfalls nicht


----------



## Leroy42 (6. Jul 2007)

Um dem ganzen Heckmeck hier mal ein Ende zu bereiten:

```
public static float sum(float[] floats) {return sum(floats, 0, floats.length-1);}
	public static float sum(float[] floats, int from, int to) {
		if (from>to)
			return 0;
		if (from==to)
			return floats[from];
		int mid = (from+to)/2;
		return sum(floats, from, mid)+sum(floats, mid+1, to);
	}
```
1. vielleicht lernt Gast ja durch Analysieren des Codes
2. Versuch mal, der Aufgabenstellung *genau* zu folgen: Also
Eine Klasse schreiben, die die floats als Instanzvariable besitzt und somit
die sum-Helper-Methode tatsächlich nur 2 Paramater benötigt (Anfang- und Endindex)


----------

