Die Methode ruft sich selbst.. rekursive?

public static int m(int i, int j)    
{     
  if ( i > j)    
    return 0;    
  else    
  {
    i++;    
    m(i++, j);
  }
  return i;    
}

Hatte ich zwei Fragen. 1.) Was wird zurückgegeben, indem out.print(m(3,8)); und 2.) Wie oft wird die Methode m aufgerufen? Das sollten auch die Antworten 5 und 7 zu entnehmen.

Wenn ich arbeitete heraus, Frage 1, ich kam mit 5 aber die Art, wie ich es Tat, es war falsch, weil die Methode nicht aufgerufen wurde, 7 mal, es wurde nur zweimal genannt. Die Art und Weise habe ich dies getan war ging ich direkt auf die else-Anweisung, da (i > j) war falsch am Anfang und Methode m aufgerufen wurde, auch dieses mal wieder mit (4, 8) ich dachte, es war immer noch falsch, also ging ich zurück zu der Zeile, wo m aufgerufen, und die variable, die ich geändert, um 5, weil die i++ im m(i++, j). Danach würde es wieder 5 für den Wert des ich.

Das war offensichtlich falsch, so fügte ich einige heraus.Drucke die Werte von i im gesamten Programm, um zu sehen, wie sich der Wert verändert und es ging von 3 bis 9 mit einer out.print(i); am Anfang der Methode m. Ein out.print(i); Recht vor return i; zeigten die Werte begonnen, gehen Sie rückwärts von 10 auf 5 und die Methode aufgerufen wurde 7 mal. Wie funktioniert das?

EDIT: Nach dem einloggen war ich in der Lage zu kommen mit etwas Logik, um es, aber ich möchte jemanden, um klarzustellen, dass es richtig ist.

Methode m aufgerufen wird mit 3,8 an den start. Nach, es ruft sich selbst mit dann 4,8 5,8....bis 9,8, wo der if-Anweisung wahr wird, und die Methode gibt 0 zurück. Es nannte sich 6 mal, so dass es beginnt, rückwärts gehen oder Dekrement-ing 6 mal so da m(i++, j) post(i), dann i wird 10 und 10 zurückgegeben wird, dann 9, dann 8, dann 7, 6, und schließlich 5. Wenn es wieder 10, 1, 9 2, 8 3, 7 4, 6 5, 5 6 war. So, da war es 6, wenn i = 5 ist, das war der Wert, der zurückgegeben wurde. Ist das richtig? Und wenn es ist, eine genauere Erklärung wäre schön zu haben.

1) Versuchen Sie es. 2) Melden Sie sich mit einer print-Anweisung.
Es gibt ähnliche Fragen wie stackoverflow.com/questions/16095176/... das könnte erklären das Verhalten.
Beantwortet ein großer Teil meiner Frage, danke

InformationsquelleAutor Oscar F | 2014-02-06

  1. 1

    Besser zu verstehen, was passiert, könnte es helfen, zu überarbeiten Sie den code als solchen:

    public static int m(int i, int j) {
    static int calls = 0;     
    System.out.println("entering.  count: " + calls);
    calls++;

    System.out.println("i = " + i);
    System.out.println("j = " + j);

    if (i > j) { 
        System.out.println("returning 0");
        return 0;
    } else {
        i++;    
        m(i++, j);
    }

    System.out.println("returning " + i);
    return i;    
}

    Hinweis, dass ich noch nicht geändert die eigentliche Logik. Alles was ich getan habe ist, fügen Sie einige Aussagen zu print-Werte, und eine variable, um zu verfolgen die Anzahl, wie oft die Methode aufgerufen wird.

    Ich änderte den code ein wenig von dem, was Sie haben, aber es ist die gleiche Logik, ich hatte einfach Probleme mit dem telefonieren, Sie waren alle null sind, so, wie Sie es, ich weiß nicht warum, aber ich fest, dass durch das ändern m (int i, int j, int-Aufrufe) und die änderung aus.print(m(3,8)) , (3,8,1) seit dem ersten Aufruf ist es. Nun, was mich verwirrt, ist, dass, was ich sehe, nur ein "i++" sind, Inkrementieren Sie den Wert des ich. Ich dachte, es würde gehen, i,j 3,8 4,8 6,8..aber es hat 5,8, aber ich bin mir nicht sicher, warum
    Mir ist nur aufgefallen das Doppelzimmer i++ nennen. Man könnte sicherlich noch System.out.println("i = " + i); Anruf zwischen i++; und m(i++,j);. Der wichtigste Punkt für meine Antwort richtig ist: Wenn Sie Zweifel haben, melden Sie es viel... (oder breakpoints verwenden).

    InformationsquelleAutor nhgrif

  2. 3

    Der Grund, warum Sie sehen den Wert Dekrementieren ist, weil, bevor Sie drucken den letzten "ich", dieser Wert ist nur erhöht, im lokalen Bereich (das erste i++ in Ihrem else-Bedingung).

    Wenn Ihr m-Funktion gibt an seinen Aufrufer, ich nicht mehr ich+1, wie es war in das Kind, so sehen Sie die Werte Dekrementieren, bis die Wurzel 'm' - Aufruf zurückgegeben wird.

    InformationsquelleAutor 75inchpianist

  3. 1

    Werde ich analysieren, die Funktion im Allgemeinen Fall, die bestimmte argument-Werte verwendet werden, die am Ende nur. Die Ausführung der Funktion und beobachten Sie, was es bedeutet via debugger oder debug-prints ist praktisch, wenn Sie solche tools, aber in bestimmten Fällen müssen Sie sich verlassen auf Ihr Gehirn, nur. E. g. es ist wirklich schwer zu ziehen debug-info aus FPGA (müssen Sie simulieren Ihre Arbeit). Bei einem Vorstellungsgespräch für einen job, Sie erhalten in der Regel einen computer, um den code zu testen – deine analytischen Fähigkeiten getestet. Das ist, warum ich empfehlen, mit Stift & Papier-Ansatz vor, der sieht, was der code wirklich tut, wenn ausgeführt.

    Frage 1: Return Wert

    Wenn Sie versuchen, zu analysieren, komplizierten code, zu wissen, was man vernachlässigen kann ist der Schlüssel zum Erfolg.

    Hier wissen Sie, dass

    • der code ist single-threaded,
    • es gibt keine globalen Variablen, keine Nebenwirkungen, die für die Welt außerhalb des aktuellen Anrufs
    • Rückgabewert des rekursiven Aufrufs wird nicht verwendet.

    So gibt es keine Notwendigkeit, darüber nachzudenken, was Durcheinander kommen könnten, aus anderen threads, können Sie analysieren die einzigen nennen, ohne zu denken, wie rekursive Aufrufe beeinflussen würde es (abgesehen von der Rückgabe Wert), und Sie können vergessen, über den rekursiven Aufruf, es sei denn, es ist eine unendliche Rekursion (die wird nicht lassen Sie Ihr Programm beenden), weil es keinen anderen Effekt, dass der Konsum von Zeit.

    Ist die Rekursion nicht unendlich ist, wie i immer erhöht, vor den rekursiven aufrufen und die Rekursion Stoppt, wenn i > j.

    Wissen, dass die Entscheidung darüber, welche der Rückgabewert ist ziemlich einfach. Die Funktion reduziert werden kann, um

    public static int m(int i, int j)
{
    if (i > j)
        return 0;
    else
        i += 2;
    return i;
}

    Weil return beendet die Ausführung der Funktion, diese kann noch weiter reduziert

    public static int m(int i, int j)
{
    return (i > j) ? 0 : i + 2;
}

    geben Ihnen die Antwort zu Frage 1. Wenn man als m(3, 8), das Ergebnis ist 0 weil i ist weniger als j.

    Frage 2: Anzahl der Anrufe

    Ist die Rekursion linear – höchstens ein rekursiver Aufruf ist in jedem Aufruf. So haben Sie zu zählen, wie viele Anrufe es dauert, bis die Unterseite der Rekursion ist erreicht.

    Den Boden der Rekursion ist der erste Zweig der Bedingung. Daher zählen Sie, wie oft ein Anruf getätigt wird, bis i > j.

    j hat den gleichen Wert in jedem der Anrufe. Es gibt keinen Befehl, um den Wert zu ändern, es ist immer an die rekursiven Aufrufs unverändert. i immer erhöht, bevor der rekursive Aufruf einmal und nach dem Aufruf einmal (i++ ist post-Inkrement, wobei die Wirkung nach der ursprüngliche Wert verwendet wird). Nur das erste Inkrement ist relevant für den rekursiven Aufruf.

    Zuliebe zählen rekursive Aufrufe, die Funktion reduziert werden kann, um

    public static void m(int i, int j)
{
    if (i > j)
        return;
    else
        m(i + 1, j);
}

    Aus diesem, ist es offensichtlich, dass i wird sukzessive um 1 erhöht, bis es größer als j.

    In m(3, 8), die Anrufe werden

    • m(3, 8),
    • m(4, 8),
    • m(5, 8),
    • m(6, 8),
    • m(7, 8),
    • m(8, 8) und
    • m(9, 8).

    Also es gibt 7 von Ihnen.

    Wenn die Parameter gegeben hatte größere Differenz, die Allgemeine Lösung wäre praktisch. So erforschen wir Sie. Es wäre schnell.

    Wenn zunächst i > j nur ein Aufruf gemacht wird, ist offensichtlich. Ansonsten... wie viele zahlen treffen Sie beim zählen von i zu j + 1? (j + 1) - i + 1 = j - i + 2. Plus eine an der ist ist für den obersten anrufen. Das ist die Allgemeine Antwort.

    InformationsquelleAutor Palec

Schreibe einen Kommentar