wie man die Rekursion nach der Rekursion in Java rekursiv macht

Question

Das Ziel ist es, die Hälfte der Länge der vorherigen Zeile auszudrucken, bis sie 0 erreicht, und dann umzukehren. wenn die ursprüngliche Größe Eingang 5 ist zum Beispiel, ist das Ergebnis:

***** 
** 
* 

* 
** 
***** 

Also schrieb ich ein Programm wie

void print(int size) { 

    if (size == 1) { 
     System.out.print("*"); 
     System.out.println();   
    } 

    if (size > 1) { 
     for (int i = 0; i < size; i++) { 
      System.out.print("*"); 
     } 
     System.out.println(); 
     size = (int)(size/2); 
     print(size); 
    } 
} 

Das Ergebnis kommt mit

***** 
** 
* 

Was das ist beste Methode, Rekursion zu verwenden, um das Ergebnis umzukehren (der zweite Teil)?

Dank

Answer 1

Sie nur auf einer Art und Weise Druck umzusetzen. Wenn Ihr Code das Ende des Stacks erreicht, passiert nichts. Lesen Sie mehr darüber, wie rekursiv tatsächlich funktioniert und was passiert, wenn Ihre Aufrufmethoden rekursiv sind.

beste Art und Weise (basierend auf Ihren Code) Ihr Ziel zu erreichen ist:

static void print(int size) { 
    if (size == 0) { 
     System.out.println(); 
    } else { 
     for (int i = 0; i < size; i++) { 
      System.out.print("*"); 
     } 
     System.out.println(); 

     print(size/2); 

     //when stack ends point of execution will go to next statement 
     //(stack ends when size==0, after that will be performed size==1, and size=2, size== 5, eop) 
     for (int i = 0; i < size; i++) { 
      System.out.print("*"); 
     } 
     System.out.println(); 
    } 
} 

Answer 2

Sie bestehende Methode druckt die ersten Sterne und dann die nächste Rekursionstiefe besuchen, die Traverse beim Überqueren eines binären Baumes wie die erste Ordnung ist.

Um das Ergebnis umzukehren, müssen Sie nur "Post Order Traverse" - besuchen Sie die nächste Rekursionsebene zuerst, dann drucken. Im folgenden Beispiel habe ich die System.out.print("*") Anweisungen nach der print(size/2) Anweisung verschoben. Es sollte erreichen, was Sie wollen.

static void print(int size) { 
    if(size==1){ 
     System.out.print("*"); 
     System.out.println(); 
    } 

    if(size>1){ 
     print(size/2); 
     for (int i = 0; i < size; i++) { 
      System.out.print("*"); 
     } 
     System.out.println(); 
    } 
} 

Answer 3

Sie den Speicher als Identität verwenden und gehen

void printReverse(int ident, int size) { 
    if (ident <= size) { 
     // quick hack , on the border case change it to the odd int 
     if (ident < size && ident * 2 > size) { 
      ident = size; 
     } 
     for (int i = 0; i < ident; i++) { 
      System.out.print("*"); 
     } 
     System.out.println(); 
     printReverse(ident * 2, size); 
    } 

} 

Answer 4

Ihre rekursive Funktion zwei Eingänge nehmen könnte:

void print(int _current, int _start){ 

    if(_current < -_start){ 
     return; 
    } 

    for(int i = 0; i < Math.abs(_current); i++){ 
     System.out.print("*"); 
    } 
    System.out.println(); 
    if(_current > 0){ 
     print(_current/2, _start); 
    } else if(_current == 0){ 
     print(-1, _start); 
    } else{ 
     print(_current * 2, _start); 
    } 
} 

EDIT: In Ihrem Fall ist die "Haupt" -Aufruf wäre Drucken (5, 5);

Answer 5

Verwenden StringBuilder Saiten und Stack baut sie für den umgekehrten Ausgang zu sammeln:

static void print(int size, Stack<String> stack) { 
    if (size == 1) { 
     System.out.println("*"); 
     stack.push("*"); 
    } else if (size > 1) { 
     StringBuilder sb = new StringBuilder(size); 
     for (int i = 0; i < size; i++) { 
      sb.append("*"); 
     } 
     String s = sb.toString(); 
     System.out.println(s); 
     stack.push(s); 
     print(size/2, stack); 
    } 
} 

public static void main(String[] args) { 
    Stack<String> stack = new Stack<>(); 
    print(5, stack); 
    while (!stack.isEmpty()) { 
     System.out.println(stack.pop()); 
    } 
}