Die Mathe-Redaktion - 21.11.2019 03:44 - Registrieren/Login
Auswahl
ListenpunktHome
ListenpunktAktuell und Interessant ai
ListenpunktArtikelübersicht/-suche
ListenpunktAlle Links / Mathe-Links
ListenpunktFach- & Sachbücher
ListenpunktMitglieder / Karte / Top 15
ListenpunktRegistrieren/Login
ListenpunktArbeitsgruppen
Listenpunkt? im neuen Schwätz
ListenpunktWerde Mathe-Millionär!
ListenpunktFormeleditor fedgeo
Schwarzes Brett
Aktion im Forum
Suche
Stichwortsuche in Artikeln und Links von Matheplanet
Suchen im Forum
Suchtipps

Bücher
Englische Bücher
Software
Suchbegriffe:
Mathematik bei amazon
Naturwissenschaft & Technik
In Partnerschaft mit Amazon.de
Kontakt
Mail an Matroid
[Keine Übungsaufgaben!]
Impressum

Bitte beachten Sie unsere Nutzungsbedingungen, die Distanzierung, unsere Datenschutzerklärung und
die Forumregeln.

Sie können Mitglied werden. Mitglieder können den Matheplanet-Newsletter bestellen, der etwa alle 2 Monate erscheint.

Der Newsletter Okt. 2017

Für Mitglieder
Mathematisch für Anfänger
Wer ist Online
Aktuell sind 132 Gäste und 4 Mitglieder online.

Sie können Mitglied werden:
Klick hier.

Über Matheplanet
 
Zum letzten Themenfilter: Themenfilter:
Matroids Matheplanet Forum Index
Moderiert von matph
Informatik » Programmieren » C: Rekursive Funktion verstehen
Druckversion
Druckversion
Antworten
Antworten
Autor
Universität/Hochschule C: Rekursive Funktion verstehen
Kagetane
Junior Letzter Besuch: vor mehr als 3 Monaten
Dabei seit: 16.06.2019
Mitteilungen: 7
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Themenstart: 2019-06-16


Wir sollen als Übungsaufgabe im Studium ein rekursives Programm betrachten und die Ausgabe aufschreiben sowie die "Tiefe" der jeweiligen Rekursion. Um auf Nummer sicher zu gehen habe ich das Programm nochmal auf meinem Computer kompiliert, aber ich verstehe nicht ganz, wie man auf die Ausgabe kommt die man kriegt.
Hier das Programm:
C
  1. #include <stdio.h>
  2. void foo(int m, int n)
  3. {
  4. printf("A: m = %i, n = %i\n", m, n);
  5. while (m < n)
  6. {
  7. foo(m + 1, n - 1);
  8. n -= 5;
  9. }
  10. printf("E: m = %i, n = %i\n", m, n);
  11. }
  12. int main(void)
  13. {
  14. foo(3, 14);
  15. }
Soweit ich das verstehe würde ich die Ausgabe beenden sobald m<n nicht mehr stimmt und man E: m=9, n=8 erhält. Aber die tatsächliche Antwort geht noch viel weiter.
Und zwar lautet sie:
A: m = 3, n = 14
A: m = 4, n = 13
A: m = 5, n = 12
A: m = 6, n = 11
A: m = 7, n = 10
A: m = 8, n = 9
A: m = 9, n = 8
E: m = 9, n = 8
E: m = 8, n = 4
E: m = 7, n = 5
E: m = 6, n = 6
A: m = 6, n = 6
E: m = 6, n = 6
E: m = 5, n = 2
A: m = 5, n = 7
A: m = 6, n = 6
E: m = 6, n = 6
E: m = 5, n = 2
E: m = 4, n = 3
A: m = 4, n = 8
A: m = 5, n = 7
A: m = 6, n = 6
E: m = 6, n = 6
E: m = 5, n = 2
E: m = 4, n = 3
A: m = 4, n = 3
E: m = 4, n = 3
E: m = 3, n = -1

Es wäre nett wenn mir jemand weiterhelfen könnte.



  Profil  Quote  Link auf diesen Beitrag Link
Creasy
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 22.02.2019
Mitteilungen: 424
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.1, eingetragen 2019-06-16


Hallo und herzlich Willkommen auf dem MP,

Mir fällt es hier schwierig zu helfen, sodass du selbst den Überblick behältst. Ich ändere daher mal die Mainmethode ab. Angenommen in der mainmethode steht foo(4,6); Jetzt durchläufst du das Programm Zeile für Zeile..
Als Erstes wird foo(4,6) aufgerufen. In dieser Methode wird als erstes etwas ausgegeben: A: m=4, n=6. Danach wird die Bedingung der Whileschleife geprüft (hier true). Also wird die Methode foo(5,5) aufgerufen, in der wiederrum wird wieder zuerst ausgegeben: A: m=5, n=5.
Danach wird auch in dieser Methode die Bedingung der Whileschleife überprüft, hier allerdings false. Man überspringt die Schleife also und landet bei dem Ausgabebefehl von E: m=5, n=5 . Die Methode foo(5,5) wurde an dieser Stelle komplett durchgeführt und man springt wieder an die Stelle zurück, an der die Methode aufgerufen wurde. Also in die WhileSchleife vom Anfang.
Wir sind also in der vom Anfang aufgerufenen Methode foo(4,6). Der nächste Befehl ist $n-=5$, also ist jetzt hier $n=1$.  Als Nächstes wird wieder die Bedingung der Whileschleife geprüft. Diese ist 4<1 false, also wird die Schleife nicht weiter durchgeführt und man springt zum letzten Befehl, der Ausgabe: E: m=4, n=1.
Danach ist auch diese Methode vollständig durchlaufen und man springt wieder an die Stelle, an der die Methode aufgerufen wurde. Das war in diesem Fall die mainMethode. Und in der Mainmethode steht nichts weiteres mehr, das Programm ist vollständig durchlaufen. Die Ausgabe in diesem Bsp ist also:
A: m=4, n=6
A: m=5, n=5
E: m=5, n=5
E: m=4, n=1


So kannst auch du dein Programm durchlaufen. Dabei hilft es sich in irgendeiner Art aufzuschreiben, welche Methoden aufgerufen werden, zb. mit Hilfe von Baumdiagrammen.


-----------------
Smile (:



  Profil  Quote  Link auf diesen Beitrag Link
viertel
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 04.03.2003
Mitteilungen: 26866
Aus: Hessen
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.2, eingetragen 2019-06-16


Hi Kagetane

Willkommen auf dem Planeten

Bei rekursiven Progammen ist es hilfreich, sich den Rekursionslevel mit anzeigen zu lassen. Entweder als Zahl (wenig übersichtlich) oder durch Einrückung.

Dieses leicht modifizierte Programm:
C
#include <stdio.h>
void foo(int m, int n, int level)
{
   printf("%*sA: m = %i, n = %i\n", 3*level, "", m, n);
   while (m < n)
   {
      foo(m + 1, n - 1, level+1);
      n -= 5;
   }
   printf("%*sE: m = %i, n = %i\n", 3*level, "", m, n);
}
int main(void)
{
   foo(3, 14, 0);
}

liefert diesen Output:
Output
A: m = 3, n = 14
   A: m = 4, n = 13
      A: m = 5, n = 12
         A: m = 6, n = 11
            A: m = 7, n = 10
               A: m = 8, n = 9
                  A: m = 9, n = 8
                  E: m = 9, n = 8
               E: m = 8, n = 4
            E: m = 7, n = 5
         E: m = 6, n = 6
         A: m = 6, n = 6
         E: m = 6, n = 6
      E: m = 5, n = 2
      A: m = 5, n = 7
         A: m = 6, n = 6
         E: m = 6, n = 6
      E: m = 5, n = 2
   E: m = 4, n = 3
   A: m = 4, n = 8
      A: m = 5, n = 7
         A: m = 6, n = 6
         E: m = 6, n = 6
      E: m = 5, n = 2
   E: m = 4, n = 3
   A: m = 4, n = 3
   E: m = 4, n = 3
E: m = 3, n = -1

Vielleicht liegt dein Problem aber auch im Verständnis, was bei Rekursion eigentlich passiert. Diese Aussage von dir:
Kagetane schreibt:
Soweit ich das verstehe würde ich die Ausgabe beenden sobald m<n nicht mehr stimmt
legt diese Vermutung nahe.

Gruß vom ¼

[Die Antwort wurde vor Beitrag No.1 begonnen.]


-----------------
Bild



  Profil  Quote  Link auf diesen Beitrag Link
viertel
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 04.03.2003
Mitteilungen: 26866
Aus: Hessen
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.3, eingetragen 2019-06-16


Einfach kommentarlos abgehakt
Kein "Jetzt hab ich's verstanden" oder sowas.
Da fragt man sich, ob man beim nächsten Mal wieder hilft frown



  Profil  Quote  Link auf diesen Beitrag Link
Kagetane hat die Antworten auf ihre/seine Frage gesehen.
Kagetane hatte hier bereits selbst das Ok-Häkchen gesetzt.
Neues Thema [Neues Thema] Antworten [Antworten]    Druckversion [Druckversion]

 


Wechsel in ein anderes Forum:
 Suchen    
 
All logos and trademarks in this site are property of their respective owner. The comments are property of their posters, all the rest © 2001-2019 by Matroids Matheplanet
This web site was made with PHP-Nuke, a web portal system written in PHP. PHP-Nuke is Free Software released under the GNU/GPL license.
Ich distanziere mich von rechtswidrigen oder anstößigen Inhalten, die sich trotz aufmerksamer Prüfung hinter hier verwendeten Links verbergen mögen.
Lesen Sie die Nutzungsbedingungen, die Distanzierung, die Datenschutzerklärung und das Impressum.
[Seitenanfang]