Rekursion

Ich hab ein Verständnisproblem bei der Rekursion...

Unter rek(3) habe ich die Reihenfolge: 10,5,16,8,4,2 =1
Jedoch warum läuft der Debugger weiter ohne die 2 mitzuzählen rückwärts die Zahlen zurück?

Die Reihenfolge ist dann, 4,8,16,5,10,3 (3 der Anfangswert). Wo ist aber die 2?
Es steht bei allen Zahlen (rückwärts: s.o.) dann der Wert =1

Hängt das mit dem Stack zusammen?

volkard

Ok, es hat was mit der Collatz-Folge zu tun.
Was genau ist dei Frage?
Falls Du fragst, wie Dein Code arbeitet, mußt Du ihn auch zeigen.

public class Ulam {

public static int proz(int n)
{
int wert=0;
if(n<=1)
{
wert=1;
}
else if(n>1 && (n%2)==0)
{
wert=proz(n/2);
}
else if(n>1 && (n%2)==1)
{
wert=proz((n*3)+1);
}
return wert;
}

public static void main(String[] args) {
System.out.println(proz(3));
}
}

Hallo nochmal,

ein weiteres Problem verstehe ich widerum nicht.
Hier wird 2 x hintereinander die Methode rekursiv aufgerufen.
Hier wird immer die n=1 aus dem Stack vermutlich geholt um die 2. Rekursion durchzuführen (obwohl n=0 ist). Aber warum geht der Compiler hier überhaupt in die 2. Methode?
Es steht eine Bedingung die nur dann ausgeführt wird wenn dies auch erreicht ist, aber warum die 2. Rekursion dennoch ausgeführt wird verstehe ich nicht.

Hier der Code:

static int t=0;
public static int doThat()
{
	t++;
	return t;
}
public static void proz(int n) 
{
	doThat();
	if (n > 0)
	{
		proz(n - 1);
		proz(n - 1); //30
		//proz(n - 1); //40???
	}
}
public static void main(String[] args) 
{
		proz(3);
		System.out.println("Aufrufe: "+t);
}

Aufrufe nach Zeit geordnet. Zweite Reihe ist zu lesen als: "In Funktion proz, die mit dem Parameter n=3 aufgerufen wurde, wird Funktion doThat aufgerufen".

main: proz( 3 )
proz(3): doThat()
proz(3): proz( 2 )
  proz(2): doThat()
  proz(2): proz( 1 )
    proz(1): doThat()
    proz(1): proz(0)
        proz(0): doThat()
    proz(1): proz(0)
        proz(0): doThat()
  proz(2): proz( 1 )
    proz(1): doThat()
    proz(1): proz(0)
        proz(0): doThat()
    proz(1): proz(0)
        proz(0): doThat()
proz(3): proz( 2 )
  proz(2): doThat()
  proz(2): proz( 1 )
    proz(1): doThat()
    proz(1): proz(0)
        proz(0): doThat()
    proz(1): proz(0)
        proz(0): doThat()
  proz(2): proz( 1 )
    proz(1): doThat()
    proz(1): proz(0)
        proz(0): doThat()
    proz(1): proz(0)
        proz(0): doThat()

Eventuelle Fehler vorbehalten..

Hier wird immer die n=1 aus dem Stack vermutlich geholt um die 2. Rekursion durchzuführen (obwohl n=0 ist). Aber warum geht der Compiler hier überhaupt in die 2. Methode?
Versteh ich nicht. Welche ist die "2. Methode"? Jede Funktion proz hat ihre eigene Variable n, viel mehr kann man da kaum erklären.