Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » Wie funktioniert dieses Programm? (Rekursion)

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 < [ 2 ]
000
22.05.2006, 17:29 Uhr
Poffelnator




C++:
#include <iostream>

using namespace std;

void rekhanoi(int x, char a, char b, char c)
{
  if(x==1)
    {
      cout << "Eine Scheibe von " << a << " nach ";
      cout << c << " legen." << endl;
      return;
    }

  rekhanoi(x-1, a, c, b);
  rekhanoi(1, a, b, c);
  rekhanoi(x-1, b, a, c);
}

void hanoi(int x)
{
  rekhanoi(x, 'A', 'B', 'C');
}





int main()
{
  int x=3;
  //cout << "Anzahl der Scheiben :";
  //cin >> x;
  hanoi(x);

  return 0;
}



Was im allgemeinen Rekursion ist, ist schon klar. Ich versteh aber nicht wie das hier funktioniert. Kann mir bitte einer das Programm von cpp ins deutsche übersetzen?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
22.05.2006, 19:03 Uhr
~gast
Gast



C++:
#include <iostream.h>
#include <conio.h>

#define MAX 50

int tuerme[MAX][3];                            //Feld für 3 Stäbe mit Max. Ringen

void turm(int n)            //Baut den Turm auf den ersten Stab und leert den 2. und 3. Stab
{
    for(int i=0;i<MAX;i++)    //1.bis 50. Ebene
    {
        tuerme[i][0]=n;        //Stab 1: Ringgröße eintragen
        tuerme[i][1]=0;        //Stab 2: leer
        tuerme[i][2]=0;        //Stab 3: leer
        n--;                //Ringgröße -1
        if (n<0) n=0;        //wenn Ring <0 dann Ring=0
    }
}

void zeige()                //Anzeigen der Türme
{
    int hoehe=0;
    for(int z=0; z<MAX; z++)    //suche maximale Turmhöhe (anfangen mit Ebene 0)
    {
        if(( tuerme[z][0]) || (tuerme[z][1]) || (tuerme[z][2]) !=0) hoehe++;
                                //wenn Ebene von Stab 1 oder Stab 2 oder Stab 3 mit Ring gefüllt
    }                            //dann hoehe +1
    for(;hoehe>=0;hoehe--)        //von oberste Ebene bis zur nullten
    {        
        for(int t=0;t<3;t++)    //Stab 1 bis 3
        {
            if(tuerme[hoehe][t]>0) cout<<tuerme[hoehe][t]<<"\t"; else cout<<"\t";            
                                //wenn Ebene von stab t vorhanden dann Ringgröße ausgeben
        }                        //sonst tabulator
        cout<<endl;                //nächster zeilenanfang
    }    
    cout<<"*\t*\t*"<<endl;        //Fuß ausgeben
    getch();                     //warte auf Tastendruck
}

int suche(int stab)                //suche unterste leerebene vom stab
{
    for(int i=0;i<MAX;i++)        //von nullebene bis max
    {
        if(tuerme[i][stab]==0) return i;    //wenn ebene leer dann rückgabe der ebene
    }
    return i;                    //max-ebene zurückgegen
}

void ebene(int nach,int von)            //ring von nach wechseln
{
    int v,n;
    v=suche(von)-1;                        //obersten ring suchen
    n=suche(nach);                        //oberste leerebene suchen
    tuerme[n][nach]=tuerme[v][von];        //ringgröße übergeben
    tuerme[v][von]=0;                    //alte pos löschen
    zeige();                            //anzeigen der Türme
}

void hanoi(int von,int nach,int rest,int n)    //Turm von nach mit hilfe von rest
                                            //mit bis zu einer Ringgröße von n wechseln
{
    if(n==2)                                //wenn ringröße=2
    {
        ebene(rest,von);                    //DANN    obersten ring "von" nach "rest" wechseln
        ebene(nach,von);                    //        obersten ring "von" nach "nach" wechseln
        ebene(nach,rest);                    //        obersten ring "rest" nach "nach" wechseln
    }
    else                                    //SONST
    {
        hanoi(von,rest,nach,n-1);            //TURM von "von" nach "rest" mit hilfe von "nach"
                                            //mit bis zu einer Ringgröße von n-1 wechseln
        ebene(nach,von);                    //obersten ring von "von" nach "nach" wechseln
        hanoi(rest,nach,von,n-1);            //TURM von "rest" nach "nach" mit hilfe von "von"
                                            //mit bis zu einer Ringgröße von n-1 wechseln
    }
    return;
}

void main(void)
{
    int n;
    cout<<"Der Turm von Hanoi\n\nWie hoch soll der Turm sein ?";
    cin>>n;
    if(n>=MAX)
    {
        cout<<"Ich hab max. "<<MAX<<" Ebenen vorgesehen"<<endl;
        n=MAX;
    }
    turm(n);                                //Turm aufbauen
    zeige();                                //Türme anzeigen
    hanoi(0,2,1,n);                            //Turm wechsle dich
}

 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
22.05.2006, 19:30 Uhr
~gast
Gast


hier klicken
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
22.05.2006, 19:42 Uhr
Poffelnator



Wie man die Ringe verschieben muss ist mir schon klar, ich versteh nur nicht was genau das Programm macht. Genau genommen versteh ich es gar nicht.


C++:
if(x==1)
    {
      cout << "Eine Scheibe von " << a << " nach ";
      cout << c << " legen." << endl;
      return;
    }

  rekhanoi(x-1, a, c, b);
  rekhanoi(1, a, b, c);
  rekhanoi(x-1, b, a, c);



was wird in diesem Teil gemacht.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
22.05.2006, 20:19 Uhr
~gast
Gast


Die Funktion rekhanoi(....) ruft sich zigmal selber auf (also rekursiv), wenn (x == 1)
return; Der Algorithmus ist rekursiv(sich selbst aufrufend). Mit x wird die Abruchbedingung
für die Rekursion festgelegt - wo ist dein Problem? Kannst du nicht versehen, dass
der Wert von x durch die Verschachtelungstiefe(Rekursion) runter geht.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
22.05.2006, 20:54 Uhr
Poffelnator



Ich versteh einfach nicht was macht das Programm?

Was passiert z.B. hier?

rekhanoi(x-1, a, c, b);
rekhanoi(1, a, b, c);
rekhanoi(x-1, b, a, c);

Wenn ich jetzt für x eine 3 setze, was macht mein Programm mit der 3?

Schritt 1.

if (x==1) stimmt nicht da 3 > 1 also weiter dann wird rekhanoi aufgerufen.

3-1 a=A b=B c=C

Schritt 2.

if (x==1) stimmt nicht da 2 > 1 also weiter dann wird rekhanoi aufgerufen.

2-1 a=A b=B c=C

Schritt 3

if (x==1) stimmt jetzt

cout << Eine Scheibe von A nach C legen

Wie geht es jetzt weiter?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
22.05.2006, 21:34 Uhr
~gast
Gast


return wird aufgerufen und Du befindest dich wieder auf der Ebene von der zuletzt
rekhanoi(...) aufgerufen wurde. Da gehts weiter und wie kannste im Debugger
verfolgen. per Einzelschritt!
Die Rekursion und das Prinzip des Kellerautomaten wird gut zu sehen sein. Wie mächtig
beide Algorithmen sind, man staunt immer wieder.

mfg
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
22.05.2006, 22:12 Uhr
~MartinF
Gast


Ich habe mal eine Abbildung erzeugt, die dir helfen soll dir rekursive Programmierung zu verstehen und zu verinnerlichen. Ich glaube wenn man einmal die rekursive Programmierung verstanden hat, sollten solche Aufgaben keine Probleme mehr bereiten.




Edit: Mist irgend was klappt mit dem Webspace nich!

Hier als ASCII-Bild


C++:
double sum_recursiv(double na, double nb)
{
  if (na==nb)
    return nb;

  return na + applikativ::sum_recursiv(na+1, nb);
}


------------------------------------------------------


sum(3, 6)

3     +     sum(3+1, 6)
                    |
                    V
                   4     +     sum(4+1, 6)
                                         |
                                         V
                                         5     +     sum(5+1, 6)
                                                             |
                                                             V
                                                             6

==>              3   +   4   +   5   +   6



Dieser Post wurde am 22.05.2006 um 22:17 Uhr von MartinF editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
22.05.2006, 22:16 Uhr
Poffelnator



Sorry aber wie kann ich dein Bild sehen?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
009
22.05.2006, 23:18 Uhr
Poffelnator



Ich glaube ich habe es jetzt verstanden. (Bin mir zwar nicht ganz sicher aber na ja) Mein größtes Verständnisproblem an diesem Programm war die schon fast mathematische Herleitung des Codes.

Aufgabe R37 aus C++ Programmierung von Addison und Wesley:

Zuerst müssen wir die triviale Lösung für dieses Problem finden. Überle­gen Sie, wie die triviale Lösung für das Spiel aussieht. Die triviale Lösung ist, wenn auf Stange A nur eine Scheibe liegt und auf C gar keine. Denn dann können wir die Scheibe einfach von A nach C bewegen.

Überlegen wir jetzt, wie wir einen Turm mit zwei Scheiben auf die triviale Lösung reduzieren. Wir legen einfach die Scheibe, die bei A auf der unter­sten Scheibe liegt, nach B. Nun ist die triviale Lösung erreicht. Bei A liegt nur eine Scheibe und bei C keine. Danach legen wir die Scheibe von B nach C, und wir haben die Lösung.
Wie sieht es bei einem Turm von drei Scheiben aus (siehe Beispiel)? Das gleiche: Wir legen erst die beiden oberen Scheiben von A mit Hilfe von C nach B. Im Beispiel haben wir damit bei Zug 3 die triviale Lösung erreicht. Danach brauchen wir einfach nur den zwei-Scheiben-großen Turm von B mit Hilfe von A nach C zu legen, und wir haben die Lösung.

Diese Art von Aufgabenstellungen und deren Lösung kenne ich sonst nur aus einer Mathevorlesung.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 < [ 2 ]     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: