Methoden rekursive Methode erstellen

[nightrider]

Guten Abend zusammen

folgendes Problem:

Aufgabenstellung:
Erstellen Sie die rekursive Methode boolean contains( int[] arr, int n, int limit).
Die Methode contains soll true zurückgeben, wenn das Feld arr im Bereich der Indizes 0 ... limit
der Wert n mindestens einmal vorkommt. Sonst soll false zurückgegeben werden. Wird ein unzulässiges
Argument für limit übergeben, soll eine IllegalArgumentException geworfen werden.
Die Implementierung darf keine Schleifen enthalten.

Mein Code:

public static boolean contains(int[] arr, int n, int limit)
{
    try
    {
        if(limit < arr.length && limit >= 0)
        {
            if(n == arr[limit])
            {
                System.out.println("true");
                return true;
            }
            else
            {
                contains(arr, n, limit - 1);
            }
        }
    }
    catch(IllegalArgumentException e)
    {
        e.printStackTrace();
    }
    System.out.println("Limit größer als Array");
    return false;
}

Ergbnis:


Frage:
Ist es so richtig? wenn nein was mache ich falsch?

Die println sind nur für mich damit ich es übersichtlicher habe und weiss wo der alles rein geht.
Mich verwirren halt diese wiederholungen wie kann ich es besser machen?

Vielen Dank schonmal im voraus

 

[Mart]

warum try und catch

warum static

 

[nightrider]

@Mart jaa wollte nicht dass intelli j das programm abbricht und static weil die methode entweder true oder false zurückgeben muss

vorhin nochmal überarbeitet

public static boolean contains(int[] arr, int n, int limit)
{
    if(limit < arr.length && limit > 0)
    {
        if(n == arr[limit])
        {
            System.out.println("true");
            return true;
        }
        else
        {
            if(limit-1>0)
            {
                System.out.println("false");
                contains(arr, n, limit - 1);
            }
            return false;
        }
    }
    else
    {
        throw new IllegalArgumentException("limit größer als arr.length");
    }
}

 

[Mart]

static weil die methode entweder true oder false zurückgeben muss

static hat nichts mit dem Rückgabewert zu tun


ausserdem kannst du diese in eine private und public aufteilen
entweder passiert dir das beim Aufruf ( das ist das einzige was die Public Methode macht) oder es passiert niemals nur du prüfst es jedes mal

throw new IllegalArgumentException("limit größer als arr.length");

dh du brauchst eine public variante die entweder
-> die private Variante startet und das Ergebnis dann returnen
-> einen Fehler ausgibt


und jetzt hast du halt einen Fehler drinnen bie der Rekursion

            if(limit-1>0)
            {
                System.out.println("false");
                contains(arr, n, limit - 1);
            }
            return false;

falls contains irgendwann mal true zurück gibt ist es immer true nur du änderst es um auf false du hast zb diese Kette als auflösung

false -> falsse -> true
dann gibt dir das letzte contains true zurück und das wars dann wirfst du es weg
und am schluss kommt false raus obwohl es nicht stimmt weil 1 mal true raus gekommen ist


es ist ansich ein XOR das du implementieren hättest sollen nur du wirfst die Ergebnisse einfach weg


der Sinn der ganzen Kiste ist ja dass man irgendwann deine Methode aufruft und dir komplett egal ist was drin passiert man möchte nur den Rückgabewert wissen und auf dem basierend macht man weiter
nur der Rückgabewert passt nicht
und die Systemouts sollten auch später noch weg zum debuggen sind sie ok

 

[nightrider]

static hat nichts mit dem Rückgabewert zu tun


ausserdem kannst du diese in eine private und public aufteilen
entweder passiert dir das beim Aufruf ( das ist das einzige was die Public Methode macht) oder es passiert niemals nur du prüfst es jedes mal

throw new IllegalArgumentException("limit größer als arr.length");

dh du brauchst eine public variante die entweder
-> die private Variante startet und das Ergebnis dann returnen
-> einen Fehler ausgibt


und jetzt hast du halt einen Fehler drinnen bie der Rekursion

            if(limit-1>0)
            {
                System.out.println("false");
                contains(arr, n, limit - 1);
            }
            return false;

falls contains irgendwann mal true zurück gibt ist es immer true nur du änderst es um auf false du hast zb diese Kette als auflösung

false -> falsse -> true
dann gibt dir das letzte contains true zurück und das wars dann wirfst du es weg
und am schluss kommt false raus obwohl es nicht stimmt weil 1 mal true raus gekommen ist


es ist ansich ein XOR das du implementieren hättest sollen nur du wirfst die Ergebnisse einfach weg


der Sinn der ganzen Kiste ist ja dass man irgendwann deine Methode aufruft und dir komplett egal ist was drin passiert man möchte nur den Rückgabewert wissen und auf dem basierend macht man weiter
nur der Rückgabewert passt nicht
und die Systemouts sollten auch später noch weg zum debuggen sind sie ok

ah ok danke ich probiere mal morgen wieder was aus bin grad danke fürs schnelle antworten

 

[Mart]

das mit dem statuc wird passiert sein weil du kein Objekt erzeugt hast wahrscheinlich. .. würde fast darauf wetten

 

[Barista]

static ist in diesem Fall in Ordnung.

 

[Barista]

Bei einer Rekursion muss sich bei jedem Schritt etwas ändern:

Deshalb ist folgendes in Ordnung:

contains(arr, n, limit - 1);

Dies hier ist nicht in Ordnung, Du weisst hoffentlich, dass in Java die erste Position/Index im Array 0 ist:

if(limit < arr.length && limit > 0)

Vor dem Aufruf oben (rekursiver Aufruf) könntest Du auf 0 prüfen, oder Du prüfst auf

limit < 0

als Abbruch-Kriterium der Rekursion.

Das ist nämlich die zweite Eigenschaft der Rekursion, man benötigt ein Abbruch-Kriterium.

Das hier ist in Ordnung:

        if(n == arr[limit])
        {
            System.out.println("true");
            return true;
        }

Das return false;

kannst Du auch noch etwas geschickter hinschreiben.

 

[Mart]

kannst Du auch noch etwas geschickter hinschreiben.

nur sein return false ist schlicht weg falsch

 

[Barista]

nur sein return false ist schlicht weg falsch

Ich meinte damit, dass nur ein else-Zweig notwendig ist.

In diesem kann das return false erfolgen.