Dieser Artikel beschreibt das kartesische Produkt von Java, das die Sammlung unbekannter Dimensionen auf der Grundlage von Rekursion und Schleife implementiert. Teilen Sie es für Ihre Referenz wie folgt weiter:
Was ist kartesisches Produkt?
In der Mathematik wird das kartesische Produkt von zwei Mengen X und Y, auch als direktes Produkt bezeichnet, als X × Y ausgedrückt. Das erste Objekt ist ein Mitglied von x und das zweite Objekt ist eines der möglichen geordneten Paare von Y.
Unter der Annahme, dass ein Satz a = {a, b} und setzt b = {0,1,2} ist, dann ist das kartesische Produkt der beiden Sätze {(a, 0), (a, 1), (a, 2), (b, 0), (b, 1), (b, 2)}.
Wie benutze ich Programmalgorithmen, um das kartesische Produkt zu implementieren?
Wenn die Anzahl der Sets vor dem Programmieren bekannt ist, kann das kartesische Produkt über mehrere Schleifen des Programms erhalten werden. Aber wenn Sie die Anzahl der Sätze vor dem Programmieren nicht kennen, wie können Sie dann das kartesische Produkt erhalten? Beispielsweise repräsentiert eine Sammlung List < List<String>> list ; Die Anzahl der Listen vor dem Programmieren ist unbekannt. Der folgende Code verwendet zwei Rekursions- und Schleifenmethoden, um das kartesische Produkt unbekannter Dimensionssätze zu implementieren:
Import Java.util.ArrayList; Import Java.util.Arrays; Import Java.util.list;/*** Zwei Möglichkeiten, um das kartesische Produkt der unbekannten Dimensionssätze zu realisieren. Dimvalue -Rohdaten* @param Ergebnisergebnisdaten* @param Layer Dimvalue -Anzahl der Ebenen* @param curlist Das Ergebnis jedes kartesischen Produkts*/ privates statisches Hohlraum Rekursiv (Liste <liste <String >> dimvalue, list <String >> Ergebnis, int, inlist, list <String> {if (Layer). == 0) {rekursiv (Dimvalue, Ergebnis, Schicht + 1, Curlist); } else {for (int i = 0; i <dimvalue.get (layer) .size (); i ++) {list <string> list = new ArrayList <string> (curlist); list.add (dimValue.get (Ebene) .get (i)); rekursiv (DimValue, Ergebnis, Schicht + 1, Liste); }}} else if (layer == dimvalue.size () - 1) {if (dimvalue.get (layer) .size () == 0) {result.add (curlist); } else {for (int i = 0; i <dimvalue.get (layer) .size (); i ++) {list <string> list = new ArrayList <string> (curlist); list.add (dimValue.get (Ebene) .get (i)); result.add (Liste); }}}} / *** Schleife Um das kartesische Produkt in Dimvalue zu implementieren, wird das Ergebnis in Ergebnis gesetzt. für (list <string> list: dimValue) {total *= list.size (); } String [] Myresult = new String [Gesamt]; int itemloopnum = 1; int LoopperItem = 1; int jetzt = 1; für (list <string> liste: dimValue) {nun *= list.size (); int index = 0; int currentSize = list.size (); itemLoopnum = total / jetzt; LooperItem = Total / (itemLoopnum * currentSize); int MyIndex = 0; für (String String: List) {für (int i = 0; i <loopperItem; i ++) {if (myIndex == list.size ()) {myIndex = 0; } für (int j = 0; j <itemLoopnum; j ++) {Myresult [index] = (Myresult [index] == null? "": myresult [index] + ") + list.get (myIndex); Index ++; } MyIndex ++; }}} List <string> stringResult = arrays.aslist (Myresult); für (String String: StringResult) {string [] stringArray = string.Split (","); result.add (arrays.aslist (stringArray)); }} / *** Programmeintrag* @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"); Liste <String> list3 = new ArrayList <string> (); list3.Add ("3"); list3.add ("4"); list3.Add ("5"); Liste <String> list4 = new ArrayList <string> (); list4.Add ("c"); list4.Add ("D"); list4.Add ("e"); Liste <Liste <string >> dimvalue = new ArrayList <list <string >> (); DimValue.Add (List1); DimValue.Add (List2); DimValue.Add (List3); DimValue.Add (List4); Liste <list <string >> recursiveresult = new ArrayList <list <string >> (); // rekursiv das kartesische Produkt rekursiv implementieren (Dimvalue, recursiveresult, 0, New ArrayList <string> ()); System.out.println ("Implementiert das kartesische Produkt rekursiv: Total" + recursisSult.size () + "Ergebnisse"); für (list <string> list: recursiveresult) {für (String String: list) {System.out.print (String + ""); } System.out.println (); } List <list <string >> circucresult = new ArrayList <list <string >> (); Schaltung (Dimvalue, CircuitResult); System.out.println ("Loop implementiert kartesische Produkt: Total" + CircuitResult.size () + "Ergebnis"); für (list <string> list: circuitResult) {für (String String: list) {System.out.print (String + ""); } System.out.println (); }}}Das Ausgangsergebnis ist:
Recursively implementing the Cartesian product: A total of 36 results1 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 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 loop implementing the Cartesian product: A total of 36 results1 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 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
Für weitere Informationen zu Java -Algorithmen können Leser, die an dieser Website interessiert sind, die Themen "Java -Datenstruktur und Algorithmus -Tutorial", "Zusammenfassung der Java -Operation DOM -Knoten -Tipps", "Zusammenfassung der Java -Datei- und Verzeichnisoperationstipps" und "Zusammenfassung der Java -Cache -Operation Tipps" anzeigen
Ich hoffe, dieser Artikel wird für Java -Programme aller hilfreich sein.