Rekursion

[Javanoob199]

Hey, ich habe eine kurze Frage warum bei der 11.Zeile steht, dass int nicht in int[] konvertiert werden kann. In den vorherigen Zeilen ging es doch.
Würde mich sehr über eure Hilfe freuen.

public static int sumUpNegatives ( int arr[],int n )
    {
       while (0<n && n<arr.length)
       {
        if (arr[n]>0)
        {
           return 0;
        }
        else
        {
            return arr[n]+sumUpNegatives(arr[n],(n-1));
        }
       }
    }

 

[DrPils]

Deine Methode erwartet ein int Array, du versuchst ihm einen int zu übergeben.
arr[n] returnt dir den int welcher in deinem Array auf position n ist.

In den vorherigen Zeilen ging es doch.

Nein.

 

[Javanoob199]

Kann ich anstelle des arr[n] einfach arr schreiben ?

 

[DrPils]

Kann ich anstelle des arr[n] einfach arr schreiben ?

Probiers doch aus.
Welchen Typ hatt arr?

 

[Javanoob199]

Habe ich, da steht jetzt aber das eine return-Anweisung fehlt

 

[DrPils]

Wenn die Methode nicht in deinen while loop geht, was soll sie dann returnen?
Bist du dir eigentlich sicher ob der while Loop hier Sinn macht? Wie oft wird er denn wiederholt?

 

[Javanoob199]

War mir bei der while Loop selber nicht sicher. Ich wusste nur nicht wie ich in die Methode einbaue, dass 0<n<arr.length ist. Da dachte ich mir ich könnte es mit einer while-Schleife lösen, scheint aber nicht so zu sein

 

[DrPils]

Also wenn es dir nur um die Überprüfung des boolean Ausdruck geht, dann sollte da wohl ein ifstehen. whilemacht nur Sinn wenn du einen Code Block wiederholt aufrufen willst.

 

[Javanoob199]

Habe das jetzt so geschrieben, wäre das so richtig ?

public static int sumUpNegatives ( int arr[],int n )
    {
        if(0>n)
        {
            throw new RuntimeException ("n cant be negative");
        }
        if(n>arr.length)
        {
            throw new RuntimeException ("n cant be longer then arr.length");
        }
        if (arr[n]>0)
        {
           return 0;
        }
        else
        {
            return arr[n]+sumUpNegatives(arr,(n-1));
        }
       
    }

 

[DrPils]

Ich weiß nicht was die Methode machen soll. Ob sie richtig ist kannst du ja testen. Die Frage ob man es evtl besser machen könnte, kann man dir beantworten wenn man weiß was du vorhast.

 

[Javanoob199]

Entwickle eine rekursive Methode int sumUpNegatives( int[] arr, int n ). Die Methode sumUpNegatives bildet die Summe der negativenWete im Feld arr im Bereich von arr[0] bis arr[n] mit 0<=n <arr.length und gibt die ermittelte Summe zurück.
Das war die Aufgabenstellung.

 

[DrPils]

Hast du es mal probiert. Läuft alles? Wenn nein was läuft nicht, was denkst du wieso es nicht läuft?

 

[Javanoob199]

Es läuft, aber wenn ich bei dem Index 0 eine negative Zahl stehen habe, wird sie nicht dazu addiert. Verstehe nicht warum.

 

[DrPils]

if (arr[n]>0) { return 0; }

Du returnst hier, sobald eine Zahl grösser als 0 ist, den Wert 0.
Willst du das so?

 

[Javanoob199]

Du returnst hier, sobald eine Zahl grösser als 0 ist, den Wert 0.
Willst du das so?

Ja, ich möchte ja nur die negativen Zahlen im Feld addieren.

 

[mihe7]

Du returnst hier, sobald eine Zahl grösser als 0 ist, den Wert 0.
Willst du das so?

Ja

Nein.

 

[Javanoob199]

Nein.

Wo liegt der Fehler?

 

[kneitzel]

Das gilt für beide Threads - denn das Problem ist bei beiden gleich:

Rekursion ist immer gleich aufgebaut:
- Du hast eine Abbruchbedingung. Es soll ja nicht endlos laufen.
- Du machst etwas, was sich selbst aufruft.

Damit kannst Du es immer selbst durchspielen:
- Was ist die Abbruchbedingung?
- Was ist zu machen, wenn kein Abbruch vorliegt.

Das musst Du als erstes sauber formulieren. Dazu brauchst Du kein Java.

Wenn ich Leute in einen Raum rekursiv leeren möchte, dann ist die Formulierung:
- Raum leer? -> fertig
- Nimm nächsten Menschen und schmeiss ihn raus. Danach neuer check (=rekursiver Aufruf)

Also auf der Ebene musst Du es formulieren - So dass Du eine klare Vorstellung vom Algorithmus hast und dies mit Stift und Papier auch durchspielen könntest. (Das ist, was Dir aus meiner Sicht derzeit fehlt!)

 

[mihe7]

Wo liegt der Fehler?

Die Antwort hat Dir @DrPils schon gegeben. Mach mal, was @kneitzel sagt und spiel es mal mit Stift und Papier durch.

 

[Javanoob199]

if (arr[n]>0)
        {
            return sumUpNegatives(arr,(n-1));
        }

Nach langen Überlegen kam ich zu diesem Ergebnis, ich habe es auch auf Stift und Papier versucht. Jedoch ist auch dieser Ansatz nicht ganz richtig , da n damit ins negative geht und ich weiß nicht wie ich es vermeiden soll.
Übrigens bin euch allen sehr dankbar für eure Antworten, insbesondere @kneitzel für Ihre ausführlichen Tipps. Ich verstehe das Prinzip, aber mir fällt es sehr schwer es umzusetzen.

 

[mihe7]

da n damit ins negative geht und ich weiß nicht wie ich es vermeiden soll.

Du sagst einfach, wenn n = 0 gilt, dann ermittle ich das Ergebnis für n und bin fertig. Das ist die Abbruchbedingung der Rekursion.

 

[Javanoob199]

if(0>n)
        {
            throw new RuntimeException ("n cant be negative");
        }
        if(n>arr.length)
        {
            throw new RuntimeException ("n cant be longer than arr.length");
        }
        if(n==0)
        {
            return arr[n];
        }
        if (arr[n]>0)
        {
            return sumUpNegatives(arr,(n-1));
        }
        else
        {
            return arr[n]+sumUpNegatives(arr,(n-1));
        }

So sieht meine fertige Methode aus. Nun gibt sie auch den korrekten Wert aus. Danke an alle die was geschrieben haben, das hat mir sehr weitergeholfen !

 

[mihe7]

Fast. Probier mal verschiedene Werte für arr[0].