Minimum in einem Array bestimmen

[hay95]

erste Aufgabe:

Implementieren Sie die Methode minHr(double[] array), welche den kleinsten Wert im Array array head-rekursiv bestimmt und das Ergebnis als double zurückgibt.

zweite Aufgabe:
Implementieren Sie die Methode countLettersHr(String str), welche alle im String str enthaltenen Klein- und Großbuchstaben head-rekursiv zählt und das Ergebnis als int zurückgibt.

Hallo, hätte jemand vielleicht einen Ansatz wie man bei den Aufgaben vorgehen kann?
Vielen Dank.
Gruß Hay95.

 

[fhoffmann]

Implementieren Sie die Methode minHr(double[] array), welche den kleinsten Wert im Array array head-rekursiv bestimmt und das Ergebnis als double zurückgibt.

- Wenn das Array die Länge 1 hat, ist das Minimum die einzige Zahl.
- Wenn das Array eine größere Länge als 1 hat, bestimme das Minimum ab dem zweiten Element und überprüfe danach, ob das erste Element oder dieses Minimum kleiner ist. Gibt das kleinere zurück.

 

[hay95]

Vielen Dank!
Allerdings habe ich Schwierigkeiten was ich beim Return genau hinschreiben soll, damit dies auch wirklich eine Head Rekursion ist. Hab nur Ideen für eine Tail-Rekursion.

 

[DrPils]

Tail oder head definiert sich ja nur darüber ob es am Ende oder am Anfang der Methode aufgerufen wird. Wenn deine Methode funktioniert und der rekursive Aufruf am Anfang steht, ist es eine head Rekursion

 

[fhoffmann]

Hab nur Ideen für eine Tail-Rekursion.

Dann schreib doch mal diesen Code auf. Normalerweise ist Tail-Rekursion schwieriger (mindestens genauso schwierig) als Head-Rekursion.

 

[hay95]

ublic static double minTr(double[] n){

return minTr(n,0,n.length-1);

}

public static double minTr(double[] numbers, int startIndex, int endIndex) { // method

if (startIndex == endIndex){

return numbers[startIndex];

}

if ( numbers[startIndex]<= numbers[endIndex]) {

endIndex -=1;

}

else {

startIndex +=1;

}
return minTr(numbers, startIndex, endIndex);

}

Also so habe ich die Tail-Rekursion gelöst

 

[fhoffmann]

Deine Tail Rekursion scheint korrekt zu sein - ich habe aber etwas gebraucht, die Idee zu verstehen.
Hier noch mal dein Code, schön formatiert:

    public static double minTr(double[] n){
        return minTr(n, 0, n.length-1);
    }

    public static double minTr(double[] numbers, int startIndex, int endIndex) {
        if (startIndex == endIndex){
            return numbers[startIndex];
        }
        if (numbers[startIndex] <= numbers[endIndex]) {
            endIndex -= 1;
        } else {
            startIndex += 1;
        }
        return minTr(numbers, startIndex, endIndex);
    }

Die Head-Rekursion ist - wie gesagt - eigentlich einfacher:

    public static double minHr(double[] numbers){
        return minHr(numbers, 0);
    }

    public static double minHr(double[] numbers, int startIndex) {
        if (numbers.length - 1 == startIndex) {
            return numbers[startIndex];
        } else { // ist nicht wirklich nötig, da zuvor ein "return"
            double minRest = minHr(numbers, startIndex + 1);
            if (minRest <= numbers[startIndex]) {
                return minRest;
            } else {
                return numbers[startIndex];
            }
        }
    }

 

[hay95]

Vielen Dank!
Ich hätte dazu eine Frage: Uns hat man den Unterschied zwischen Tail und Head Rekursion so beigebracht, dass bei head mit dem rekursiven Funktionsaufruf etwas gemacht wird wie z.B Multipliziert oder Addiert. Während es bei Tail im Prinzip eine Variable gibt in der die Lösung gespeichert wird, sodass beim return nur der Methodenaufruf mit den Parametern übergeben wird. Aber hier wird doch nichts mit dem Methodenaufruf noch gemacht z.B. keine Addition. Könnt ihr mir vielleicht erklären warum dieser Code trotzdem head Rekursiv ist?

 Fakultät  head-rekursiv:                                                               
public static int fakHr(int n){
    if(n==0){
        return 1;
    }
    else {
        return n*fakHr(n); //mit dem Methodenaufruf wird noch etwas gemacht
    }
}

Fakultät Tail :
public static int FakTr(int n){
    return FakTr(n,1);
}
public static int FakTr(int n,int k){
    if(n==0){
        return k;
    }
    else {
        return FakTr(n-1,n*k) //durch n*k wird das Ergebnis gleich mitgerechnet
    }
}