Je voudrais demander à tout le monde une explication détaillée de l'algorithme récursif en Java.

Je voudrais vous demander une explication détaillée de l'algorithme récursif en Java

Test en classe publique{

public static int getResult (paramètre int) {

if (paramètre == 0) { renvoyer le résultat ; } autre { résultat *= paramètre ; return récursiveFunction (paramètre - 1, résultat); }

numéro de retour ;

}

public static void main(String[] args) { //Écrivez votre code ici }

int résultat = résultat(5);

System.out.println(result);

}

}

Son principe d'exécution est le suivant :

result(5) Dans un premier temps, entrez le corps de la fonction pour déterminer si le paramètre est inférieur ou égal à 1. À ce moment, le paramètre est égal à 5 ​​et la condition n'est pas établie. Paramètre*résultat(paramètre-1) est exécuté, c'est-à-dire 5 * résultat (5-1), et le programme est exécuté à plusieurs reprises...

.

5*résultat(5-1)

4*résultat(4-1)

3*résultat(3-1)

2 * result(2 - 1) À ce stade, le paramètre est égal à 1 et remplit les conditions. La fonction renvoie 1 et couche par couche. C'est à dire :

résultat(1) =1

2*résultat(1)=2*1=2

3*résultat(2)=3*2=6

4*résultat(3)=4*6=24

5*résultat(4)=5*24=120

Utilisez la méthode récursive en Java pour organiser complètement n nombres sans duplication n 3

Le programme est le suivant, le format d'entrée est :

5

3 1 2 1 2 signifie que la première ligne est un nombre, indiquant le nombre de nombres à saisir ensuite. La deuxième ligne contient n nombres, représentant les nombres à trier. L'entrée suppose que les nombres à trier sont tous des nombres non négatifs.

importer java.io.File ;

importer java.io.FileNotFoundException;

importer java.util.Arrays ;

importer java.util.Scanner ;

cours public principal {

statique final int maxn = 1000;

int n; //Nombre d'éléments du tableau

int[] a; // tableau

boolean[] used; // Variable auxiliaire, utilisée pour marquer si l'élément a été utilisé pendant le processus récursif, used[i] indique si le i-ième élément a été utilisé

int[] cur; // Enregistre le numéro d'arrangement actuel

// Imprimez de manière récursive l'intégralité de l'arrangement sans duplication, en imprimant actuellement à la position idx

void print_comb(int idx) {

Si idx == n, cela signifie que le dernier élément a été parcouru et cur peut être sorti.

pour(int i = 0; i

if(i > 0) System.out.print(＂ ＂);

System.out.print(cur[i]);

}

System.out.println();

}

int last = -1; // Afin d'éviter la duplication, utilisez la dernière variable pour enregistrer la valeur de la dernière recherche

pour(int i = 0; i

if(used[i]) continue ;

if(last == -1 || a[i] != last) { // Ce n'est que lorsque le numéro actuel n'est pas répété et n'a pas été utilisé que la récursion continuera

dernier = a[i];

cur[idx] = a[i];

//Méthode de backtracking

utilisé[i] = vrai;

print_comb(idx + 1);

utilisé[i] = faux;

}

}

}

public void go() lance FileNotFoundException { // Implémente le corps de la méthode }

{

Scanner in = new Scanner(new File("data.in")); La syntaxe consiste à créer un objet Scanner nommé in, qui est utilisé pour lire l'entrée du fichier nommé data.in.

//Lire les données et trier

n = in.nextInt();

a = nouveau int[n];

pour (int i = 0; i

Arrays.sort(a);

//Initialisez les variables auxiliaires et démarrez l'arrangement complet sans duplication

cur = nouveau int[n];

utilisé = nouveau booléen[n];

pour(int i = 0; i

print_comb(0);

in.close();

}

public static void main(String[] args) lance FileNotFoundException { Il s'agit de la méthode principale d'un programme Java, utilisée pour démarrer l'entrée du programme. Dans cette méthode, nous pouvons effectuer certaines opérations, telles que la lecture de fichiers, le traitement de données, etc. Parmi eux, l'exception FileNotFoundException indique qu'une exception de fichier introuvable peut se produire lors de l'exécution. Si cette exception se produit, le programme lèvera une exception FileNotFoundException. Dans cette méthode, vous pouvez écrire une logique de code spécifique pour gérer la lecture des fichiers et la gestion des exceptions.

nouveau Main().go();

}

} Objectivement parlant, les permutations complètes non récursives et non répétitives sont relativement simples et efficaces.

Quel est le rôle de la récursivité en Java ? Pourquoi utiliser la récursion

Vos deux questions sont en fait une seule question, n'est-ce pas ?

Le rôle de la récursivité : Les algorithmes récursifs peuvent résoudre certains problèmes définis par la récursivité.

Tout d'abord, nous devons comprendre quel est le problème de la définition récursive. En termes simples, un problème défini de manière récursive est un gros problème qui contient des problèmes plus petits ayant la même structure mais de plus petite taille.

Par exemple, la définition de n factorielle peut être comprise comme :

n!= n*(n-1)!

Il n'est pas difficile de conclure de l'analyse ci-dessus que (n-1) ! est un problème plus petit que n !. En décomposant continuellement le problème selon cette méthode, nous pouvons obtenir des données de base connues. Ensuite, grâce à la dérivation inverse, nous pouvons obtenir le résultat final.

L'algorithme factoriel de

n est le suivant :

private static int jieCheng(int n) { Il s'agit d'une méthode de calcul factoriel, où le paramètre n représente la valeur à calculer. Voici une explication détaillée : - "privée" signifie que la méthode n'est visible que dans la classe actuelle et n'est pas accessible aux autres classes. - "statique" signifie que la méthode est une méthode statique et peut être appelée directement via le nom de la classe sans instancier l'objet. - "int" signifie que la méthode renvoie une valeur entière comme résultat. - "jieCheng" est le nom de la méthode, qui peut être nommée selon les besoins.

si(n==1)

retour 1;

autre {

retour n*jieCheng(n-1);

}

}

De plus, la définition d'un arbre binaire est également récursive, ce qui signifie que de nombreuses opérations sur les arbres binaires sont implémentées par récursion.

L'utilisation de la récursivité rend le programme assez concis.

Application de récursivité en java ! f20 1 f21 4 fn 2 2 fn 1 fnoù

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

Test de classe publique {

publicstaticintf(intn){

si(n==20){

retour1;

}elseif(n==21){

retour4;

}elseif(n

retourf(n+2)-2*f(n+1);

}autre{

retour2*f(n-1)+f(n-2);

}

}

public static void main(String[] args) {

System.out.println(f(10)); //Imprimer la valeur de f(10)

}

}

Il a été testé. Entrez f(n) dans la fonction principale, où n est un paramètre ajusté manuellement, et le résultat de sortie correspondant peut être obtenu.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!