Klassen Rekursion mit Feldern von Objekten

[nightrider]

Guten Tag alle zusammen

bin relativ neu was Java betrifft und komme bei einer Aufgabe nicht weiter. Die Aufgabe lautet:
"Entwickeln Sie eine rekursive Methode Fraction maximum( Fraction[] arr, int i ), die für ein Feld arr das Maximum im Bereich von arr[0] bis arr mit 0<=i<arr.length bestimmt und zurückgibt."
Fraction ist eine Klasse die vorgegeben und fertig ist.

hier ist, dass was ich bisher hab sind Fehler drinnen weiss aber nicht was ich genau falsch gemacht habe.

    public Fraction maximum(Fraction[] arr, int i)
    {
        int max=0;
        if(i>=0 && i<arr.length)
        {
            max=maximum(arr, i-1);
            if(max<arr[i])
            {
                max=arr[i];
            }
            else
            {
                max=maximum(arr, i+1);
            }
        }
        return max;
    }

Vielen Dank schonmal im voraus.

 

[httpdigest]

Du benötigst auf jeden Fall eine zweite "private" Hilfsmethode mit einem Akkumulator-Argument, welches zu jedem rekursiven Aufruf/Abstieg das "aktuell beste Maximum" repräsentiert.
Quatsch, brauchst du garnicht.
Guck dir nochmal deinen Abbruchbedingungsfall an. Hier lieferst du einfach nur `max` zurück.

EDIT: Hint: Jeder rekursive Aufruf für `i` berechnet ja das Maximum aller restlichen Elemente von `i` bis `arr.length - 1`. Was wäre denn das Maximum, wenn `i` = `arr.length - 1` ist, du also das Maximum eines einzigen Elementes berechnen würdest...

 

[MoxxiManagarm]

Du benötigst auf jeden Fall eine zweite "private" Hilfsmethode mit einem Akkumulator-Argument, welches zu jedem rekursiven Aufruf/Abstieg das "aktuell beste Maximum" repräsentiert.

Wieso??

hier ist, dass was ich bisher hab sind Fehler drinnen weiss aber nicht was ich genau falsch gemacht habe.

Ehrlich gesagt blick ich bei dir garnicht durch, zu verwirrend ^^
Ich glaube nicht, dass du 2 Fraction Elemente einfach mit > etc. vergleichen kannst. Wie sehen die Vergleichsmethoden in Fraction aus?

public Fraction maximum(Fraction[] arr, int i) {
  if (i == 0) return arr[0];
  return max(arr[i], maximum(arr, i - 1)); // max ist bei mir einfach ein Platzhalter für eine Methode die entscheidet welches das größere Fraction Object ist
}

 

[nightrider]

Ehrlich gesagt blick ich bei dir garnicht durch, zu verwirrend ^^
Ich glaube nicht, dass du 2 Fraction Elemente einfach mit > etc. vergleichen kannst. Wie sehen die Vergleichsmethoden in Fraction aus?

kriege auch die fehlermeldung das ich 2 fraction objects nicht mit einadner verglichen kann

 

[nightrider]

Das ist Fraction

public class Fraction
{
    private int numerator;      // Zaehler
    private int denominator;    // Nenner

    public Fraction ( int num, int denom )
    {
        if ( denom != 0 )
        {
            if ( denom < 0 )
            {
                numerator = -num;
                denominator = -denom;
            }
            else
            {
                numerator = num;
                denominator = denom;
            }
            reduce();
        }
        else
        {
            // error: division by zero
            throw new IllegalArgumentException();
        }
    }

    public Fraction()
    {
        numerator = 0;
        denominator = 1;
    }

    public Fraction( int num )
    {
        numerator = num;
        denominator = 1;
    }

    public String toString()
    {
        return numerator + " / " + denominator;
    }

    public Fraction changeSign()
    {
        return new Fraction( -numerator, denominator );
    }

    public Fraction reverse()
    {
        return new Fraction( denominator, numerator );
    }

    public Fraction add( Fraction other )
    {
        int num = numerator * other.denominator + other.numerator * denominator;
        int denom = denominator * other.denominator;
        return new Fraction ( num, denom );
    }

    public Fraction subtract( Fraction other )
    {
        int num = numerator * other.denominator - other.numerator * denominator;
        int denom = denominator * other.denominator;
        return new Fraction ( num, denom );
    }
    
    /*
       * alternative Implementierung zu Fraction subtract
         *
    public Fraction subtract( Fraction other)
    {
        return add ( other.changeSign() );
    }
    *
     *
      */

    public Fraction multiply( Fraction other )
    {
        int num = numerator * other.numerator;
        int denom = denominator * other.denominator;
        return new Fraction ( num, denom );
    }

    public Fraction divideBy( Fraction other )
    {
        return multiply ( other.reverse() );
    }

    public double toDouble()
    {
        //Type-Cast (double) erzeugt den dem int-Wert des nachfolggenden Attributs entsprechenden double-Wert, der dann in die Division eingeht   (primitver-Typ) explizit nach der rechnung umwandeln da sonst Rundungsfehler entstehen können
        return (double)numerator / (double)denominator;
    }

    public Fraction clone()
    {
        return new Fraction( numerator, denominator );
    }   

    public boolean equals( Fraction other )
    {
        return numerator == other.numerator & denominator == other.denominator;
    }

    private void reduce()
    {
        if ( numerator != 0 )
        {
            int gcd = calculateGcd();
            numerator /= gcd;
            denominator /= gcd;
        }
        else
        {
            denominator = 1;
        }
    }
    
    public int calculateGcd()
    {
        int value1 = Math.abs( numerator );
        int value2 = denominator;
        while (value1 != 0 & value2 != 0)
        {
            if ( value1 > value2 )
            {
                value1 = value1 % value2;
            }
            else
            {
                value2 = value2 % value1;
            }
        }
        if ( value1 == 0 )
        {
            return value2;
        }
        else
        {
            return value1;
        }
    }   
}

 

[MoxxiManagarm]

Fraktion hat die Methode toDouble(). Die kannst du zum Vergleichen verwenden

 

[nightrider]

Hat jemand Lösungsvorschläge wie man es machen könnte?

 

[httpdigest]

@MoxxiManagarm hat dir in https://www.java-forum.org/thema/rekursion-mit-feldern-von-objekten.186651/#post-1203633 bereits eine Lösung geschrieben. Du benötigst halt nur noch eine kleine Hilfsmethode `max`, mit der du das Maximum von genau zwei Fraction Objekten bestimmen kannst.

 

[MoxxiManagarm]

hab ich doch? Mein Code oben ist der rekursive Ansatz. Dann musst du nur noch toDouble() aufrufen von den vergleichselemente für die Entscheidung welches größer ist

 

[nightrider]

habt ihr einen Lösungsweg ohne eine Hilfsmethode zu erstellen ?

 

[MoxxiManagarm]

Fraction right = arr[i];
Fraction left = maximum(arr, i - 1);
return left.toDouble() > right.toDouble() ? left : right;

Weil ich gerade im Bus sitze mit Smartphone habe ich mir erspart die Signatur und Abbruchbedingung nochmal mit abzutippen

 

[nightrider]

@MoxxiManagarm danke nochmals

 

[MoxxiManagarm]

@nightrider Ich hätte heute einen guten Tag und hab dir die Lösung präsentiert. Ich möchte nur sicher gehen, dass du sie auch verstanden hast und beim nächsten mal selbst erstellen kannst. Kannst du es nachvollziehen? Hast du fragen?

 

[mihe7]

Ich hätte heute einen guten Tag

@nightrider Du musst wissen, Moxxi ist normalerweise eine von der ganz bösen Sorte

 

[nightrider]

@MoxxiManagarm Ja hab das Prinzip verstanden würde aber nie drauf kommen es so zu machen Danke nochmals. @mihe7 da hatte ich wohl Glück