Rekursion auf einem Array(negative werte addieren)

[canyakan95]

public static int sumUpNegatives(int[]arr, int i)
    {
        if(i==arr.length-1)
        {
            if(arr[i]<0)
            {
                return arr[i];
            }
            else{
                throw new RuntimeException();
            }
        }
        else
        {
            if(arr[i]<0)
            {
                int result= arr[i]+sumUpNegatives(arr,i+1);
                return result;
            }
            else{
                return sumUpNegatives(arr,i+1);
            }
        }

 

[njans]

Keine Frage, na dann kann man auch nicht helfen.
Code bitte in Java Tags.

 

[canyakan95]

Meine Frage ist , ob ich die Rekursion richtig eingesetzt habe und verstanden habe??
Mfg

 

[njans]

throw new RuntimeException();

Naja die macht erstmal wenig Sinn. Warum kriegt man nur eine RE, wenn der letzte index nicht negativ ist?

Rekursiv ist es, ja, auch die Grundidee scheinst du verstanden zu haben, allerdings kriegst du immer eine ArrayIndexOutOfBounds Exception, da dein i irgendwann über das Array hinausgeht.

 

[minzee]

Also mir fällt nur auf, dass du nicht einen bestimmten Programmierstil konsequent einsetzt.

Komma: oben bei den Argumenten machst du nach dem Komma ein Leerzeichen, in allen anderen Fällen nicht.

{: nach dem else schreibst du das { in die gleiche Zeilen, in allen anderen Fällen nicht. In Java hast du grundsätzlich die freie Wahl, eine dieser Varianten (gibt noch andere) auszuwählen. Allerdings solltest du hier den Stil wählen, den ihr an der Schule bzw. Uni verwendet.

Ich würd das so schreiben (nicht getestet):

public static int addNegatives(int[] values, int i) 
{
   if(i >= values.length - 1)
   {
      if(values[i] < 0)
      {
         return values[i]; 
      }
      throw new RuntimeException();
   }
   if(values[i] < 0)
   {
      int result = values[i] + addNegatives(values, i + 1);
      return result;
   }
   return addNegatives(values, i + 1);
}

Die folgenden Punkte sind reine Geschmackssache:

Eine Arrayvariable nach ihrem Typ zu benennen, find ich irgendwie nicht so elegant. Darum habe ich mit "values" versucht, einen sprechenderen Namen zu finden.

"sumUp" hab ich - glaub ich - auch noch nie gelesen. "add" liest man aber oft.

Die else´es habe ich rausgenommen. Nach einem return oder throw erscheint mir das irgendwie unnötig.

Aber ich vermute, dein Programm macht das, was es machen soll Nur das public kommt mir etwas seltsam vor. Nachdem hier auch eine Zählvariable i übergeben wird, schaut mir das eher nach einer private-Methode aus. Vielleicht wäre es so besser:

private static int addNegatives(int[] values, int i)
{
   if(i >= values.length - 1)
   {
      if(values[i] < 0)
      {
         return values[i];
      }
      throw new RuntimeException();
   }
   if(values[i] < 0)
   {
      int result = values[i] + addNegatives(values, i + 1);
      return result;
   }
   return addNegatives(values, i + 1);
}
public static int addNegatives(int[] values)
{
   return addNegatives(values, 0);
}

Das >= ist nur aus Fehlertoleranzgründen (Ein Fehler, der hoffentlich - und auch wahrscheinlich - nie eintreten wird).

Ich vermute, von außen soll man keine Möglichkeit haben, das i zu übergeben.

Du könntest das Array übrigens auch verkehrtrum durchlaufen. Dann musst du nur ein einziges mal ganz am Anfange values.length - 1 rechnen:

private static int addNegatives(int[] values, int i)
{
   if(i <= 0)
   {
      if(values[i] < 0)
      {
         return values[i];
      }
      throw new RuntimeException();
   }
   if(values[i] < 0)
   {
      int result = values[i] + addNegatives(values, i - 1);
      return result;
   }
   return addNegatives(values, i - 1);
}
public static int addNegatives(int[] values)
{
   return addNegatives(values, values.length - 1);
}

Allerdings habe ich das nicht getestet. Ich glaube, da gibts ein Problem, wenn das Array leer ist :bahnhof: Habe ich auch nicht bei deiner ursprünglichen Variante geprüft. Ich weiß auch nicht, wie dein Programm auf ein leeres Array reagieren soll.

Sofern es auch bei einem leeren Array 0 zurückgeben soll, könnte man die Sache auch ganz anders angehen. Dann könnte man vielleicht in der Abbruchbedingung statt einem Arrayelement einfach nur 0 zurückgeben.

Was soll eigentlich das Ergebnis bei z. B. {-1, -4} sein? -5 oder 5?