Я не понимаю эту рекурсивную программу

Question

У меня есть этот код, который использует рекурсию для получения каждой возможной комбинации символов для любой введенной строки. Но я не понимаю, что происходит, когда программа работает! Может кто-нибудь объяснить, что происходит в этой программе? Я по-прежнему новичок в программировании, поэтому я был бы признателен, если бы ваше объяснение не было слишком сложным, спасибо!

public class WordJumble { 
    public static void main(String[] args) { 
    String letters = "WORD"; 
    jumbleWords(letters, ""); 
    } 

    //input parameters 
    //word - the remaining letters in the word still to jumble 
    //jumbLet - the letters already used to create the jumbled word 

    public static void jumbleWords(String word, String jumbLet) { 
    int pos; 
    String remainingLetters; 
    String origWord = word; 
    String origJumbledLetters = jumbLet; 
    if (word.length() == 1) 
     System.out.println(jumbLet + word); 
    else { 
     for (pos = 0; pos < origWord.length(); pos++) { 
     remainingLetters = origWord.substring(0, pos) + origWord.substring(pos + 1, origWord.length()); 
     //recursive call to jumbleWords() 
     jumbleWords(remainingLetters, origJumbledLetters + origWord.charAt(pos)); 
     } 
    } 
    } 
} 

Выход затем:

WORD 
WODR 
WROD 
WRDO 
WDOR 
WDRO 
OWRD 
OWDR 
ORWD 
ORDW 
ODWR 
ODRW 
RWOD 
RWDO 
ROWD 
RODW 
RDWO 
RDOW 
DWOR 
DWRO 
DOWR 
DORW 
DRWO 
DROW 

Спасибо за вашу помощь!

Answer 1

Что это рекурсивный алгоритм делает: принимают в исходной строке «WORD»

Затем перемещает один символ в то время, когда этот персонаж был перемещен его отслеживает, которые были созданы подстроки, и который символы не были перемещены. он передает его обратно в него сам, чтобы перепутать слово.

поз + 1 перемещает элемент символа в следующей позиции строки

Answer 2

Если вы печатаете из рекуррентных вызовов и добавить дополнительный параметр, который запоминает глубину рекурсии (и перевести на вкладку-символов), вы можете прекрасно наблюдать, что происходит:

public class WordJumble { 
    public static void main(String[] args) { 
    String letters = "WORD"; 
    jumbleWords(letters, "", 0); 
    } 

    //input parameters 
    //word - the remaining letters in the word still to jumble 
    //jumbLet - the letters already used to create the jumbled word 

    public static void jumbleWords(String word, String jumbLet, int recursionDepth) { 
    int pos; 
    String remainingLetters; 
    String origWord = word; 
    String origJumbledLetters = jumbLet; 

    String tabs = ""; 
    if(recursionDepth > 0) { // translate recursionDepth to tab-characters 
     tabs = String.format("%0" + recursionDepth + "d", 0).replace("0","\t"); 
    } 

    if (word.length() == 1) 
     System.out.println(tabs + jumbLet + " + " + word); 
    else { 
     for (pos = 0; pos < origWord.length(); pos++) { 
     remainingLetters = origWord.substring(0, pos) + origWord.substring(pos + 1, origWord.length()); 
     //recursive call to jumbleWords() 
     System.out.println(tabs + "jumbleWords("+remainingLetters+", "+origJumbledLetters + " + " + origWord.charAt(pos) + ");"); 
     jumbleWords(remainingLetters, origJumbledLetters + origWord.charAt(pos), recursionDepth + 1); 
     } 
    } 
    } 
} 

выход:

jumbleWords(ORD, + W); 
    jumbleWords(RD, W + O); 
     jumbleWords(D, WO + R); 
      WOR + D 
     jumbleWords(R, WO + D); 
      WOD + R 
    jumbleWords(OD, W + R); 
     jumbleWords(D, WR + O); 
      WRO + D 
     jumbleWords(O, WR + D); 
      WRD + O 
    jumbleWords(OR, W + D); 
     jumbleWords(R, WD + O); 
      WDO + R 
     jumbleWords(O, WD + R); 
      WDR + O 
jumbleWords(WRD, + O); 
    jumbleWords(RD, O + W); 
     jumbleWords(D, OW + R); 
      OWR + D 
     jumbleWords(R, OW + D); 
      OWD + R 
    jumbleWords(WD, O + R); 
     jumbleWords(D, OR + W); 
      ORW + D 
     jumbleWords(W, OR + D); 
      ORD + W 
    jumbleWords(WR, O + D); 
     jumbleWords(R, OD + W); 
      ODW + R 
     jumbleWords(W, OD + R); 
      ODR + W 
jumbleWords(WOD, + R); 
    jumbleWords(OD, R + W); 
     jumbleWords(D, RW + O); 
      RWO + D 
     jumbleWords(O, RW + D); 
      RWD + O 
    jumbleWords(WD, R + O); 
     jumbleWords(D, RO + W); 
      ROW + D 
     jumbleWords(W, RO + D); 
      ROD + W 
    jumbleWords(WO, R + D); 
     jumbleWords(O, RD + W); 
      RDW + O 
     jumbleWords(W, RD + O); 
      RDO + W 
jumbleWords(WOR, + D); 
    jumbleWords(OR, D + W); 
     jumbleWords(R, DW + O); 
      DWO + R 
     jumbleWords(O, DW + R); 
      DWR + O 
    jumbleWords(WR, D + O); 
     jumbleWords(R, DO + W); 
      DOW + R 
     jumbleWords(W, DO + R); 
      DOR + W 
    jumbleWords(WO, D + R); 
     jumbleWords(O, DR + W); 
      DRW + O 
     jumbleWords(W, DR + O); 
      DRO + W