# Rekursion!!



## mark (3. Dez 2009)

Hallo zusammen,
hier ist eine frage die ich nicht dazu komme alleine zu Programmieren, also ich ein Neuling in java und vor allem Rekursion. Würde mir jemanden sagen wie ich am besten mit dieser frage um gehen kann! 

4)Gegeben ist ein Array von Integerzahlen. Definieren Sie eine Funktion maxZahl, die das 
größte Element in dem Array sucht. Das Programm soll rekursiv das erste Element im 
Array mit dem größten Element im restlichen Array vergleichen. 
    publc static int maxZahl(int a[], int l, int r){ //methode anfang schon vorgegeben
 ......
 ......
} 
so viel ich weiss es geht um Teile und herrsche, die structur sowie ihre weisst lautet
 static int max(int a[],int l, int r){
    if(l==r) return a[l];
    int m=(l+r)/2;
    int u=max(a,l,m);
    int v=max(a,m+1,r)
    if(u>v) return u;
    else
          return v;
}
Ich bedanke mich im voraus.
mark


----------



## Marco13 (3. Dez 2009)

Hab' den Code nicht getestet, sieht aber ganz plausibel aus ... was ist denn die Frage?


----------



## partsch (3. Dez 2009)

Also bei mir sieht die Lösung so aus:

```
public class Main {
	
	public static void main(String[]args){
		System.out.println("MaxNumber: "+getMaxNumber(12, 45, 1, 99, 23, 11));
	}
	
	public static int getMaxNumber(int...numbers){
		return getMaxNumber(numbers, 0);
	}
	
	private static int getMaxNumber(int[]numbers, int position){
		if(position+1<numbers.length){
			numbers[position+1] = (numbers[position]>numbers[position+1]) ?
					numbers[position]	:	numbers[position+1];
			return getMaxNumber(numbers, position+1);
		}
		return numbers[position];
	}
}
```
man muss einfach nur in den Parameter schreiben welche Zahlen er verwenden soll im Array die andern 2 Parameter kann man auch in der Methode schreiben.


----------



## mark (4. Dez 2009)

Marco13 hat gesagt.:


> Hab' den Code nicht getestet, sieht aber ganz plausibel aus ... was ist denn die Frage?


Die frage lautet so:

4) Gegeben ist ein Array von Integerzahlen. Definieren Sie eine Funktion maxZahl, die das 
größte Element in dem Array sucht. Das Programm soll rekursiv das erste Element im 
Array mit dem größten Element im restlichen Array vergleichen. 

publc static int maxZahl(int a[], int l, int r){ //diese methode anfang ist schon vorgegeben. d.h von  hier soll ich weiter machen. Anders gehts natürlich auch, aber am besten wäre es wenn ich die gegebene parameter verwenden konnte.
Danke.     
......


----------



## Marco13 (4. Dez 2009)

Das ist keine Frage, sondern eine Aufgabenstellung, und durch den Code, den du schon gepostet hast, ist sie gelöst, falls er funktioniert.


----------



## mark (6. Dez 2009)

Ok der Code, den du mir gegeben hattest, hat funktioniert. Nun ich habe paar fragen;
du hast 2 getMax() methoden verwendet ,von dem zweiten habe ich verstanden worum es geht, aber bei dem ersten, ich weiß nicht genau was da geschiet vor allem die Signatur getMax(int .....numbers) is für mich was neues ,kannst du da bitte  erklären. Ich weiß das nachdem position+1=numbers.length dann wird return numbers[position] zurückgegeben and springt das programm zu den ersten  getMaxNumbers() methode.Was passiert dann ?
Und kann man das program so schreiben das es den Array in zwei teile teilt ab den Index[position+1] ,index[0] sollte nicht beteiligt sein und nach dem ich von dem restlichen zahlen das großte bekommen habe dann tue ich das großte zahl mit dem wert von index[0] vergleichen, aber alles soll rekursive sein???
ich habe versucht so zu programmieren aber es hat überhaupt nicht geklappt so sah es bei mir aus:
public static int maxZahl(int a[], int l,int r)
{
      if(r==l) return a[l];
      int m=((l+1)+r)/2;
      int u=maxzahl(a,l+1,m);
      int v=maxZahl(a,m+1,r);
      if (u>v && a[0]>u) return u;
      else
      if (v>u && v>a[0])return v;
         else return a[0];
}
die idee ist sowie ich oben gesagt habe,restliche Array ab a[1] dann nach dem ich die grösste zahl bekommen habe vergleiche ich mit a[0]. Aber das program funktioniert nicht
Was mache ich falsch? ist es meine dank weisse "approach" order gibts ein Trick das man wissen muss wenn er sich mit rekursive arbeitet?
ich kann eine Idee habe aber wie ich anfangen soll ist echt ein Problem. Kannst du mir vielleicht Tricks geben!!
sowie gesagt ich bin am lernen.
danke und ich freu mich auf deine Antwort


----------



## DigitalForce (6. Dez 2009)

hi, meine lösung sieht so aus...

wenn das array leer sein sollte wird momMax zurückgegeben


```
public class MaxInt {

    public static void main(String[] args) {
        int[] array = {30, 4, 7, 3, 22, 12, 20, 16, 13, 25};
        int ergebnis = max(array, 0, 0);
        System.out.println("Größte Zahl im Array ist : " + ergebnis);
    }

    public static int max(int[] array, int start, int momMax) {
        if (start < array.length) {
            if (momMax < array[start]) {
                momMax = array[start];
            }
            return max(array, ++start, momMax);
        } else {
            return momMax;
        }
    }
}
```


----------



## JohannisderKaeufer (6. Dez 2009)

Laut fragestellung soll "die erste Zahl" mit "der größten Zahl des restlichen Arrays" überprüft werden.


```
public static int maxZahl(int[] a){
return maxZahl(a,0,0);
}

publc static int maxZahl(int[] a, int l, int r){
if(a.length==r){
return a[r-1];
}else
if(a[r]>maxZahl(a,l,r+1){
return a[r];
}else{
return maxZahl(a,l,r+1);
}
}
```
Da geht sowas in die richtigere Richtung.
Oder alternativ. Die eine Variabel r, bzw. l ist zuviel, es reichen definitiv das Array + eine Variable. Selbst diese ist eine Variable kann vernachlässigt werden, wenn man neue Arrays anlegen würde.
Die Signatur mit den zwei Variablen macht lediglich Sinn wenn man die geforderte Implementierung austauschbar halten will mit einer Implementierung alla Teile und Herrsche.

```
static int max(int[] a){
return max(a, 0, a.length-1);
}

static int max(int a[],int l, int r){
if(l==r) return a[l];
//int m=(l+r)/2;
int u=max(a,l,l);
int v=max(a,l+1,r);
if(u>v) return u;
else
return v;
}
```


----------



## partsch (7. Dez 2009)

Hier ist mein Code nochmal kommentiert, wie du wolltest

```
public class Main {
	
	public static void main(String[]args){
		System.out.println("MaxNumber: "+getMaxNumber(512, 45, 991, 99, 223, 611));
	}
	
	
	public static void nothing(String s){
		s.replace('a', 'b');
	}
	/*
	 * Mit der Signatur int ... numbers schreibe ich der Methode vor das der Benutzer (zB wie in main) keinen Array
	 * erzeugen muss sondern einfach die Elemente mit der der Interne Array der Methode arbeiten soll hintereinander schreiben.
	 * also man muss nur getMaxNumber(1, 34, 56, 99) schreiben und die Methode generiert automatisch einen Array mit:
	 * a[0] ... 1
	 * a[1] ... 34
	 * a[2] ... 56
	 * a[3] ... 99
	 */
	public static int getMaxNumber(int...numbers){
		numbers = getMaxNumber(numbers, 1);
		return numbers[0];
	}
	
	/*
	 * Hier geht die Methode als Rekursion den im Parameter übergebenen Array durch und 
	 * speichert, immer wenn es eine größere Zahl findet, diese in a[0] ab und so ist die
	 * größte Zahl im endeffeckt in a[0]
	 */
	private static int[] getMaxNumber(int[]numbers, int position){
		if(position < numbers.length){ 
			if(numbers[0] < numbers[position]){ // wenn der positions-teil im array größer als der erste ist wird getauscht
				int save = numbers[0];
				numbers[0] = numbers[position];
				numbers[position] = save;
			} getMaxNumber(numbers, position+1);
		}
		return numbers; 
	}
}
```


----------

