Problem mit return

[Veget]

Hallo zusammen,

leider wird mir immer der Wert MAX_Value zurückgegeben. Ich kann es mir jedoch nicht erklären und hab auch schon einiges ausprobiert. Ich weiß jedoch keine Möglichkeit mehr woran es liegen könnte. Ich hoffe ihr könnt mir helfen.
Danke.

	/*
	 * Soll durch Aufruf einer rekursiven Methode das minimale Element eines
	 * Arrays finden.
	 */
	protected int minRekursiv(int[] x) {
		int min = Integer.MAX_VALUE;
		int ersterWert = x[0];
		int letzterWert = x[x.length-1];
		 
		if ( x.length < 2) {
			 min = x[0];
		 }
		else{
			 if (ersterWert <= letzterWert) {
				 int y[] = new int[x.length-1]; 
				
				 for (int i = 0; i < x.length-1; i++) {
					y[i] = x[i];
				}
				minRekursiv(y);
			} else {
				 int y[] = new int[x.length-1]; 
				
				 for (int i = 1; i < x.length; i++) {
					 y[i-1] = x[i];
				 }
				 minRekursiv(y);
			}
		}
		return min;
	}

Mit freundlichen Grüßen

Veget

 

[Kel]

int min = Integer.MAX_VALUE;

Du änderst min nirgendwo, wieso soll was anderes als MAX_VALUE zurückgegeben werden?

 

[Veget]

Danke für den Tipp. Danke für den Tipp. Ich hab den min Wert zwei Mal zu wenig geändert.

	protected int minRekursiv(int[] x) {
		int min = Integer.MAX_VALUE;
		int ersterWert = x[0];
		int letzterWert = x[x.length-1];
		 
		if ( x.length < 2) {
			 min = x[0];
		 }
		else{
			 if (ersterWert <= letzterWert) {
				 int y[] = new int[x.length-1]; 
				
				 for (int i = 0; i < x.length-1; i++) {
					y[i] = x[i];
				}
			min = minRekursiv(y);
			} else {
				 int y[] = new int[x.length-1]; 
				
				 for (int i = 1; i < x.length; i++) {
					 y[i-1] = x[i];
				 }
			min = minRekursiv(y);
			}
		}
		return min;
	}

 

[Crian]

Da ist mir etwas zu viel doppelter Code. Wie wäre e so?

public class Recursion1 {

    public static void main(String[] args) {
        int[] a = { 1, 4, 2, 963836, -4, 2, 0 };
        int min = minRekursiv(a);
        System.out.println(min);
    }

    public static int minRekursiv(int[] x) {
        int min = Integer.MAX_VALUE;
        int ersterWert = x[0];
        int letzterWert = x[x.length - 1];

        if (x.length < 2) {
            min = x[0];
        }
        else {
            int y[] = new int[x.length - 1];
            if (ersterWert <= letzterWert) {
                for (int i = 0; i < x.length - 1; i++) {
                    y[i] = x[i];
                }
            }
            else {
                for (int i = 1; i < x.length; i++) {
                    y[i - 1] = x[i];
                }
            }
            min = minRekursiv(y);
        }
        return min;
    }

}

Oder so (nur die Methode):

    public static int minRekursiv(int[] x) {
        int min = Integer.MAX_VALUE;
        int ersterWert = x[0];
        int letzterWert = x[x.length - 1];

        if (x.length < 2) {
            min = x[0];
        }
        else {
            int y[] = new int[x.length - 1];
            boolean ersterKleiner = ersterWert <= letzterWert;
            for (int i = 0; i < x.length - 1; i++) {
                if (ersterKleiner)
                    y[i] = x[i];
                else
                    y[i] = x[i+1];
            }
            min = minRekursiv(y);
        }
        return min;
    }

oder gar so:

    public static int minRekursiv(int[] x) {
        int min = x[0];
        if (x.length > 1) {
            int y[] = new int[x.length - 1];
            boolean ersterKleiner = x[0] <= x[x.length - 1];
            for (int i = 0; i < x.length - 1; i++) {
                if (ersterKleiner)
                    y[i] = x[i];
                else
                    y[i] = x[i+1];
            }
            min = minRekursiv(y);
        }
        return min;
    }

 

[Veget]

Hi Crian,

die zweite Methode ist cool. Danke.


Mit freundlichen Grüßen
Veget

 

[Crian]

Danke. Ich hab noch eine dritte dazu gebastelt.

 

[ThreadPool]

Es geht auch ohne umständliches Umkopieren. Ich persönlich würde noch mal von vorne beginnen.

 

[Landei]

Easy:

    public static int minRekursiv(int... x) {
        return minRekursiv(x, 0);
    }

    private static int minRekursiv(int[] x, int index) {
        return (index == x.length)
                ? Integer.MAX_VALUE
                : Math.min(x[index], minRekursiv(x, index + 1));
    }