Rekursion endet nie selbst mit Return-Anweisung

Question

Ich kann nicht verstehen, was die return-Anweisung tut (ich dachte, es gab nur eine Variable zurück und erlaubte mir, die Schleife zu verlassen). Ich versuche, Rekursionen besser zu verstehen, aber das scheint nie zu enden.

import java.util.Arrays; 
import java.util.List; 

public class main { 

    public static void main(String[] args) { 
     System.out.println("Starting.."); 
     List<Integer> list_to_start = Arrays.asList(new Integer[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}); 
     String[] name_of_list_to_start = new String[] {"grapes", "Strawberries", "Raspberries", "Blackberries", "Pineapples", "Oranges", "Prunes", "Pears", "cherries", "Peaches", "Apples"};  
     System.out.println(list_to_start.size()); 
     counter(list_to_start.size(), list_to_start, name_of_list_to_start); 
    } 

    private static void counter(int length, List<Integer> list_to_start, String[] name_of_list_to_start) { 
     // TODO Auto-generated method stub 
     if (length == 0) { 
      System.out.println("List is empty now"); 
      for (int i = 0; i>=list_to_start.size(); i++) { 
       System.out.println(name_of_list_to_start[i] + " = " + list_to_start.get(i)); 
      } 
      return; 
     } 
     Integer x_lenght = (Integer) list_to_start.get(length-1); 
     for (int i = 0; i<=5; i++) { 
      //System.out.println(i); 
      if (length != 0) { 
       list_to_start.set((length-1), i); 
       counter((length-1), list_to_start, name_of_list_to_start); 
       list_to_start.set((length-1), 0); 
      } 
     } 
    } 
} 

Im Grunde, was ich versuche zu tun, eine Rekursion, herauszufinden, alle Kombinationen von 0-5 für 10 verschiedene Früchte (dies nur für mich ist nicht zu lernen, einen Student homework..not).

Irgendeine Idee, was ich falsch mache? Warum stoppt dieses Programm nicht mit der return-Anweisung?

Update: falls jemand immer das gleiche Problem hat, ist hier die Arbeitsversion des obigen Code (den gebrochenen Code zu halten, so dass die Antworten Sinn machen):

import java.util.Arrays; 
import java.util.List; 

public class main { 

    public static void main(String[] args) { 
     System.out.println("Starting.."); 
     List<Integer> list_to_start = Arrays.asList(new Integer[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}); 
     String[] name_of_list_to_start = new String[] {"grapes", "Strawberries", "Raspberries", "Blackberries", "Pineapples", "Oranges", "Prunes", "Pears", "cherries", "Peaches", "Apples"};  
     System.out.println(list_to_start.size()); 
     counter(list_to_start.size(), list_to_start, name_of_list_to_start); 
    } 

    private static void counter(int length, List<Integer> list_to_start, String[] name_of_list_to_start) { 
     // TODO Auto-generated method stub 
     if (length == 0) { 
      //System.out.println("List is empty now"); 
      for (int i = 0; i<list_to_start.size(); i++) { 
       //(name_of_list_to_start[i] + " = " + list_to_start.get(i)); 
       int k = i +2; 
       int y = k -1; 
      } 
      //System.out.println("********"); 
      return; 
     } 
     Integer x_lenght = (Integer) list_to_start.get(length-1); 
     for (int i = 0; i<=5; i++) { 
      //System.out.println(i); 
      if (length != 0) { 
       list_to_start.set((length-1), i); 
       counter((length-1), list_to_start, name_of_list_to_start); 
       list_to_start.set((length-1), 0); 
      } 
     } 
    } 
} 

Answer 1

Sind Sie sicher, dass dies eine Endlosschleife und nicht nur eine wirklich lange Sequenz?

Auf jeder Ebene Sie Schleife 5 mal, Verzweigung zu einer anderen Rekursion jedes Mal. Sie haben 10 Stufen, also haben Sie insgesamt 5^10 Funktionsaufrufe auf der untersten Ebene oder 9.765.625 System.out.println Aufrufe!

Ihre Return-Anweisung ist nicht in einer Schleife. Die return-Anweisung beendet den aktuellen Funktionsaufruf ... aber Sie haben hier mehr als 10 Millionen Funktionsaufrufe, daher muss sie oft zurückkommen.

Answer 2

Ihre Bedingung in der for-Schleife, wenn length = 0 sollte

i<list_to_start.size() 

sein und wie Riley sagte, muss Ihr Rekursion etwas gezwickt werden.