Cet article décrit le produit cartésien de Java mettant en œuvre la collection de dimensions inconnues basées sur la récursivité et la boucle. Partagez-le pour votre référence, comme suit:
Qu'est-ce que le produit cartésien?
En mathématiques, le produit cartésien de deux ensembles X et Y, également connu sous le nom de produit direct, est exprimé en X × Y, le premier objet est un membre de X et le deuxième objet est l'une de toutes les paires ordonnées possibles de Y.
En supposant que l'ensemble a = {a, b} et set b = {0,1,2}, alors le produit cartésien des deux ensembles est {(a, 0), (a, 1), (a, 2), (b, 0), (b, 1), (b, 2)}.
Comment utiliser les algorithmes de programme pour implémenter le produit cartésien?
Si le nombre d'ensembles est connu avant la programmation, le produit cartésien peut être obtenu via plusieurs boucles du programme. Mais si vous ne connaissez pas le nombre d'ensembles avant la programmation, comment pouvez-vous obtenir le produit cartésien? Par exemple, une collection représente List < List<String>> list ; Le nombre de listes avant la programmation est inconnu. Le code suivant utilise deux méthodes de récursivité et de boucle pour implémenter le produit cartésien des ensembles de dimensions inconnus:
Importer java.util.arraylist; importer java.util.arrays; importer java.util.list; / ** * Deux façons de réaliser le produit cartésien de dimensions inconnues * créée le 2015-05-22 * @author luweijie * / public class descartes {/ ** * Recursived le produit cartesien dans DIMVALU Donvalue data brut * @param Résultat Données de résultat * @param couche DimValue Nombre de couches * @param couronne le résultat de chaque produit cartésien * / private static void récursif (list <list <String> CurList) {if (list <dimvalue.size () - 1) { (dimValue.get (couche) .size () == 0) {récursif (dimValue, result, couche + 1, couronne); } else {for (int i = 0; i <dimValue.get (couche) .size (); i ++) {list <string> list = new ArrayList <string> (curList); list.add (dimValue.get (couche) .get (i)); récursif (dimValue, résultat, couche + 1, liste); }}} else if (couche == dimValue.size () - 1) {if (dimValue.get (couche) .size () == 0) {result.add (curList); } else {for (int i = 0; i <dimValue.get (couche) .size (); i ++) {list <string> list = new ArrayList <string> (curList); list.add (dimValue.get (couche) .get (i)); result.add (list); }}}} / ** * boucle Pour implémenter le produit cartésien dans DimValue, et le résultat est placé dans le résultat * @param dimValue Données brutes * @Param Result Data * / Private Static void circuit (list <list <String>> DimValue, list <list <string>> Result) {int total = 1; for (list <string> list: dimValue) {total * = list.size (); } String [] myResult = new String [Total]; int itemloopnum = 1; int loopperitem = 1; int maintenant = 1; for (list <string> list: dimValue) {maintenant * = list.size (); int index = 0; int CurrentSize = list.size (); itemloopnum = total / maintenant; loopperitem = total / (itemloopnum * CurrentSize); int myindex = 0; for (String String: list) {for (int i = 0; i <loopperitem; i ++) {if (myIndex == list.size ()) {myIndex = 0; } pour (int j = 0; j <itemloopnum; j ++) {myResult [index] = (myResult [index] == null? "": myResult [index] + ",") + list.get (myIndex); index ++; } MyIndex ++; }}} List <string> stringResult = arrays.aslist (myResult); pour (String String: StringResult) {String [] StringArray = String.Split (","); result.add (arrays.aslist (stringArray)); }} / ** * Entrée de programme * @param args * / public static void main (String [] args) {list <string> list1 = new ArrayList <string> (); list1.add ("1"); list1.add ("2"); List <string> list2 = new ArrayList <string> (); list2.add ("a"); list2.add ("b"); List <string> list3 = new ArrayList <string> (); list3.add ("3"); list3.add ("4"); list3.add ("5"); List <string> list4 = new ArrayList <string> (); list4.add ("c"); list4.add ("d"); list4.add ("e"); List <list <string>> dimValue = new ArrayList <list <string>> (); dimValue.add (list1); dimValue.add (list2); dimValue.add (list3); dimValue.add (list4); List <list <string>> récursivesult = new ArrayList <list <string >> (); // Implémentez récursivement le produit cartésien récursif (dimValue, récursiveResult, 0, new ArrayList <string> ()); System.out.println ("Recursivement implémente le produit cartésien: total" + récursivesult.size () + "résultats"); for (list <string> list: recursiverResult) {for (String String: list) {System.out.print (String + ""); } System.out.println (); } List <list <string>> circuitResult = new ArrayList <list <string>> (); circuit (dimvalue, circuitrsult); System.out.println ("Loop implémente le produit cartésien: Total" + circuitResult.size () + "Result"); for (list <string> list: circuitResult) {for (String String: list) {System.out.print (String + ""); } System.out.println (); }}}Le résultat de la sortie est:
Implémentation récursive du produit cartésien: un total de 36 résultats1 a 3 c1 a 3 d1 a 3 e1 a 4 c1 a 4 d1 a 4 e1 a 5 c1 a 5 d1 a 5 e1 b 3 c1 b 3 d1 b 3 e1 b 4 c1 b 4 d1 b 4 e1 b 5 c1 b 5 d1 b 5 e2 a 3 c2 a 3 d2 a 3 e2 a 4 c2 a 4 d2 a 4 a 3 c2 a 3 d2 a 3 e2 a 4 c2 a 4 d2 a 4 a 3 c2 a 3 d2 a 3 e2 a 4 c2 a 4 d2 a 4 a 3 c2 a 3 d2 a 3 e2 a 4 C2 a 4 d2 a 4 a 3 C2 A 3 D2 A 3 E2 A 4 C2 A 4 A 4 A 3 C2 A 5 D2 A 5 E2 B 3 C2 B 3 D2 B 3 E2 B 4 C2 B 4 D2 B 4 E2 B 5 C2 B 5 D2 B 5 E boucle Implémentation du produit cartésien: A total de 36 résultats1 A 3 C1 A 3 D1 A 3 E1 A 4 C1 A 4 D1 A 4 E1 A 5 C1 A 5 D1 A 5 E1 B 3 C1 B 3 D1 B 3 E1 B 4 C B 4 B 5 C1 B 5 D1 B 5 E2 A 3 C2 A 3 D2 A 3 E2 A 4 C2 A 4 D2 A 4 E2 A 5 C2 A 5 D2 A 5 E2 B 3 C2 B 3 D2 B 3 E2 B 4 C2 B 4 D2 B 4 E2 B 5 C2 B 5 D2 B 5 E
Pour plus d'informations sur les algorithmes Java, les lecteurs qui sont intéressés par ce site peuvent afficher les sujets: "Structure de données Java et tutoriel d'algorithme", "Résumé des conseils de nœud de Dom Operation Java", "Résumé du fichier Java et des conseils d'opération de répertoire" et "Résumé des conseils d'opération Java Cache"
J'espère que cet article sera utile à la programmation Java de tous.