In diesem Artikel wird Ihnen vorgestellt, wie Sie die Funktion von zufälligen, keine sich wiederholenden Zahlen in Java implementieren können. Wenn Sie ein Anfänger sind, ist es erforderlich, diesen Artikel zu lesen, da diese Funktion im Allgemeinen während der Interviews auftritt. Einschließlich, wenn ich Menschen rekrutiere, frage ich auch gerne andere nach dieser Frage, hauptsächlich, um zu sehen, wie das Modell und die Grundkenntnisse des Problems berücksichtigt werden.
Ich hoffe, dieser Artikel kann Freunden helfen, die zum ersten Mal in Kontakt stehen, weil ich einige Freunde kontaktiert habe, die ihn entweder nicht schreiben oder eine sehr flache Denkweise verwenden, um ihn zu erreichen.
Im Allgemeinen können Freunde mit einigen Entwicklungserfahrungen solche Funktionen umsetzen, aber es ist nur eine Frage der Effizienz. Wenn wir solchen Problemen konfrontiert sind, denken wir immer in einer geraden Reihenfolge daran und fügen dann dem Array in einer Schleife zufällige Zahlen hinzu. Suchen Sie beim Hinzufügen von Zahlen zunächst nach, ob diese Zahl im Array vorhanden ist. Wenn diese Nummer nicht vorhanden ist, wird sie direkt zum Array hinzugefügt. Wenn diese Zahl vorhanden ist, wird sie nicht hinzugefügt. Wir betrachten das Problem normalerweise auf diese Weise und können Funktionen auf diese Weise implementieren. Wie ich gerade sagte, ist es nur eine Frage der Effizienz.
Um die Bedeutung dieser Frage besser zu verstehen, schauen wir uns zunächst den spezifischen Inhalt an: Generieren Sie ein zufälliges Array von 1 bis 100, aber die Zahlen im Array können nicht wiederholt werden, dh die Positionen sind zufällig, aber die Elemente des Arrays können nicht wiederholt werden.
Hier haben wir die Länge des Arrays nicht angegeben, wir können es zwischen 1 und 100 zu einer beliebigen Länge machen.
Schauen wir uns als nächstes mehrere Implementierungsmethoden an und vergleichen Sie diese Methoden .
Normalerweise verwenden wir ArrayList oder Array, um es zu implementieren. Schauen wir uns zunächst den Implementierungsprozess von ArrayList an, wie im folgenden Code gezeigt:
Import Java.util.ArrayList; Import Java.util.Random;/** * Implementierung mit ArrayList * @Description: * @File: Demo.java * @Package None * @Author Hanyonglu * @date 2012-10-18 06:55 pm * @version v1.0 */public class). Objekt [] values = neues Objekt [20]; Random random = new random (); ArrayList <Integer> list = new ArrayList <GanzEger> (); für (int i = 0; i <values.length; i ++) {int number = random.nextint (100)+1; if (! list.contains (number)) {list.add (number); }} values = list.toArray (); // Durchqueren Sie das Array und drucken Sie die Daten für (int i = 0; i <values.length; i ++) {System.out.print (Werte [i]+"/t"); if ((i + 1) % 10 == 0) {System.out.println ("/n"); }}}} Der Implementierungsprozess mit Arrays ist wie folgt:
Importieren Sie Java.util.random;/** * Implementierung mit Arrays * @Description: * @file: Demo4.java * @package none * @author hanyonglu * @date 2012-10-18 06:27:38 PM * @VERSION V1.0 */public class Demo4 {public static static void Main (String [] {] {int [int []; Random random = new random (); für (int i = 0; i <values.length; i ++) {int number = random.nextint (100)+1; für (int j = 0; j <= i; j ++) {if (number! = values [j]) {values [i] = nummer; }}} // das Array durchqueren und die Daten für (int i = 0; i <values.length; i ++) {System.out.print (Werte [i]+"/t"); if ((i + 1) % 10 == 0) {System.out.println ("/n"); }}}} Die beiden oben genannten Implementierungsprozesse sind relativ ineffizient. Denn jedes Mal, wenn Sie hinzufügen, müssen Sie durchqueren, ob diese Zahl in der aktuellen Liste vorhanden ist, die Zeitkomplexität ist O (n^2). Wir können auf diese Weise darüber nachdenken: Da es keine Duplizierung gibt, können wir über die Funktionen von Hashset und HashMap nachdenken. Hashset implementiert die festgelegte Schnittstelle, und die mathematische Definition von SET ist ein Satz ohne Duplikation und Reihenfolge. HashMap implementiert MAP, und es ist auch ein Schlüssel, der keine Duplikate zulässt. Auf diese Weise können wir HashMap oder Hashset verwenden, um es zu erreichen.
Bei der Verwendung von HashMap -Implementierung müssen Sie seinen Schlüssel nur in ein Array umwandeln, und es wird wie folgt in Ordnung sein:
import java.util.HashMap;import java.util.Iterator;import java.util.Random;import java.util.Map.Entry;/** * Implementation using HashMap* @Description: * @File: Demo.java * @Package None * @Author Hanyonglu * @Date 2012-10-18 06:12:50 pm * @Version V1.0 */public class Demo {public static void main (String [] args) {int n = 0; Objekt [] values = neues Objekt [20]; Random random = new random (); HashMap <Objekt, Objekt> HashMap = new Hashmap <Objekt, Objekt> (); // Zufallszahlen generieren und HashMap für (int i = 0; i <values.length; i ++) {int number = random.Nextint (100)+1; Hashmap.put (Nummer, i); } // Array -Werte aus HashMap -Werten = hashmap.keyset (). ToArray (); // Durchqueren Sie das Array und drucken Sie Daten für (int i = 0; i <values.length; i ++) {System.out.print (Werte [i]+"/t"); if ((i + 1) % 10 == 0) {System.out.println ("/n"); }} // iterator iter = hashMap.EntrySet (). Iterator (); // // traversal hashmap // while (iter.hasnext () {// Eintrag <IngEger, Integer> Iter.Next (); "/t"); // // if (n % 10 == 0) {// system.out.println ("/n"); //} //}}} Da die Beziehung zwischen Hashset und HashMap zu nahe ist, wird Hashset mit HashMap unten implementiert, aber es gibt keine Wertsammlung und nur eine Sammlung von Schlüssel, sodass sie auch wie folgt mit Hashset implementiert werden kann:
import java.util.HashSet;import java.util.Random;/** * Implementation using HashSet* @Description: * @File: Test.java * @Package None * @Author Hanyonglu * @Date 2012-10-18 06:11:41 pm * @Version V1.0 */public class Test { public static void main(String[] args) { Random random = new Zufällig(); Objekt [] values = neues Objekt [20]; Hashset <Gefeger> Hashset = new Hashset <GanzEger> (); // Zufallszahlen generieren und Hashset für (int i = 0; i <values.length; i ++) {int number = random.Nextint (100)+1; Hashset.Add (Nummer); } values = HashSet.toArray (); // Durchqueren Sie das Array und drucken Sie Daten für (int i = 0; i <values.length; i ++) {System.out.print (Werte [i]+"/t"); if ((i + 1) % 10 == 0) {System.out.println ("/n"); }}}} Dies ist etwas effizienter. Wenn wir die Länge des Arrays begrenzt haben, müssen wir nur die für die Schleife verwandeln und auf eine WHLIE -Schleife einstellen. Wie unten gezeigt:
import java.util.HashSet;import java.util.Random;/** * Implementation using HashSet* @Description: * @File: Test.java * @Package None * @Author Hanyonglu * @Date 2012-10-18 05:11:41 pm * @Version V1.0 */public class Test { public static void main(String[] args) { Random random = new Zufällig(); Objekt [] values = neues Objekt [20]; Hashset <Gefeger> Hashset = new Hashset <GanzEger> (); // Zufallszahlen generieren und hashset speichern (Hashset.size () <values.length) {Hashset.Add (random.Nextint (100) + 1); } values = HashSet.toArray (); // Durchqueren Sie das Array und drucken Sie die Daten für (int i = 0; i <values.length; i ++) {System.out.print (Werte [i]+"/t"); if ((i + 1) % 10 == 0) {System.out.println ("/n"); }}}}Wir können die Länge des Arrays auf 100 einstellen und den in der folgenden Abbildung gezeigten Laufeffekt überprüfen:
Im Vergleich zu den oben genannten ist die Verwendung von HashMap relativ effizient. Tatsächlich ist es ein Hashset, ein Array und schließlich eine Arraylist. Wenn wir 10000 Daten generieren, werden wir feststellen, dass die Verwendung von HashMap einige Zeit dauert: 0,05s, Hashset beträgt 0,07s, Array 0,20s und ArrayList beträgt 0,25s. Wenn Sie interessiert sind, können Sie sich die Zeit festlegen, es zu überprüfen.
Natürlich gibt es nicht nur die HashMap -Implementierung, sondern auch andere effiziente Methoden. Zum Beispiel können wir die Nummern 1-100 in einem Array speichern und dann zufällig zwei Indexs in der für Schleife generieren. Wenn diese beiden Einweise nicht gleich sind, können wir Elemente im Array austauschen. Der Implementierungsprozess ist wie folgt:
Importieren Sie java.util.random;/** * Implementierung von zufälligen Position Conversion * @Description: * @File: Demo4.java * @package none * @author hanyonglu * @Date 2012-10-18 06:54:06 PM * @VERSION V1.0 */public class Demo4 {public intat static void Main (String [] {] {public int. int temp1, temp2, temp3; Random r = neu random (); für (int i = 0; i <values.length; i ++) {values [i] = i+1; } // zufällig wechseln Werte aus. // zufällig eine Position erzeugen temp2 = math.abs (r.NextInt ()) % (Werte.Length-1); // zufällig eine andere Position if (temp1! = Temp2) {temp3 = values [temp1] erstellen; Werte [temp1] = Werte [temp2]; Werte [temp2] = TEMP3; }} // Überqueren Sie das Array und drucken Sie die Daten für (int i = 0; i <20; i ++) {System.out.print (Werte [i]+"/t"); if ((i + 1) % 10 == 0) {System.out.println ("/n"); }}}} Diese Methode ist ebenfalls relativ effizient. Wenn 10.000 Daten generiert werden, beträgt die Zeit, die sie benötigt, 0,054S.
Basierend auf der Implementierung von Koordinaten in einem Array können mehr verwandte Lösungen transformiert werden, und Sie können relevante Informationen im Detail verweisen.
Bei der oben genannten Bearbeitung geht es darum, die Funktion zufälliger, nicht repetitiver Zahlen in Java zu implementieren. Natürlich sind die Methoden nicht auf diese Typen beschränkt, aber es gibt andere Implementierungsmethoden. Ich hoffe, dass es für Freunde, die schon eine Weile in Kontakt sind, hilfreich sein wird, und ich hoffe, dass es eine Rolle bei der Anziehung und Anziehung von Jade spielen kann.
Original -Website: http://www.cnblogs.com/hanyonglu/archive/2012/10/18/2730007.html
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.