Comment ce code récursif fonctionne-t-il en essayant de comprendre le concept mais de ne pas avoir à travers

Ne soyez pas confus sur le code récursif - AFAIK, cela pourrait être fait sans code récursif.

On dirait qu'il trie le contenu de la variable AR dans une nature détruite et supprime des doublons. Mais si la valeur n'existe pas dans AR, elle imprime simplement A pour chaque élément d'AR. Et si un existe dans AR, il imprime la prochaine valeur supérieure, Et si cela existe dans AR, il imprime la prochaine valeur supérieure, Mais si la valeur liquidation d'A n'existe pas dans AR, imprimez-la simplement pour les itérations de boucle restantes. P>

public void find(int ar[], int a) {        
    for (int i = 0; i < ar.length; i++) {
        System.out.println(a);

        if (doesArrayContain(ar, a)) {
            //System.out.println(a+" "+i)
            a = a + 1;
        }
    }
}

private boolean doesArrayContain(int ar[], int a) {
    for (int idx = 0; idx < ar.length; idx++) {
        if (ar[idx] == a) {
            return true;
        }
    }
    return false;
}

Il apparaît que vous commencez avec

boucle en boucle d'un biais d'un entier "de taille de taille n 'pour trouver une valeur" A " Si cela existe, vous avez ensuite recommandé de trouver 'A + 1' P>

main.find [1,2], 1
console >>    1
    first recursive [1,2], 2.      --------  match for 1
    consoles >> 2
        second recursive [1,2] 3.  --------  match for 2
        consoles >> 3
        exit second recursive (no match for 3)
    third recursive [1,2], 2.      --------  match for 2
    consoles >> 3
    exit third recursive (no match for 3)
loop ends  

lorsque vous entrez xxx

• n = le premier numéro = 2
• ar = NEXT N (2) numéros = [1,2]
• a = quatrième Numéro = 1

  alors la méthode de recherche est appelée comme suit: xxx

  pour la sortie: Inside Trouvez la méthode

  • a = 1 est imprimé. comme passé de la méthode principale.
  • ar = [1,2] est itéré.
  • car a [0] = 1 = a , A est incrémenté à 2. Recherche (AR = [1,2], A = 2) est appelé.
    • a = 2 est imprimé.
    • ar = [1,2] est itéré.
    • cette fois a [0] = 1! = A = 2.
    • élément suivant, a [1] = 2 = A , A est incrémenté à 3. Rechercher (ar = [1,2], A = 3) est appelé.
      • a = 3 est imprimé. .
      • ar = [1,2] est itéré.
      • aucun élément dans AR n'est égal à a = 3 .
      • a [1] = 2 = A . a a été tourné de 1 à 2 dans l'itération précédente . Encore une fois a = 2 + 1 = 3 . Recherche (AR = [1,2], A = 3) est appelé.
        • a = 3 est imprimé. .
        • ar = [1,2] est itéré.
        • Aucun élément dans AR n'est égal à A = 3.

          sortie finale: xxx

          point à note:

          Si vous modifiez la valeur du type primitif Variables (comme int a ) à l'intérieur d'un appel récursif, la modification n'affectera pas la valeur de A pour la fonction mère.