Methoden zum Implementieren der Randomisierung von Wertindizes in Arrays und zum Erstellen zufälliger Arrays in Javascript_Javascript-Kenntnissen

Das Beispiel in diesem Artikel beschreibt die Methode zum Randomisieren des Werteindex im Array und zum Erstellen eines Zufallsarrays mithilfe von JavaScript. Teilen Sie es als Referenz mit allen. Die Details lauten wie folgt:

Heute habe ich in der QW-Kommunikationsgruppe gesehen, wie einige Studenten das Problem der Randomisierung von Arrays diskutierten. Der angegebene Algorithmus war sehr gut und erinnerte mich an die nicht so „schöne“ Methode, die ich zuvor implementiert hatte. Denken Sie darüber nach: Manchmal, wenn wir damit beschäftigt sind, Geschäftscode zu schreiben, nur um seine Funktion zu implementieren, denken wir nicht viel darüber nach, ob es eine bessere Implementierungsmethode gibt.

Was dieses Array-Problem betrifft (dann die Werte in einem Array sortieren und ein neues Array zurückgeben), war meine bisherige Implementierungsmethode wie folgt:

function randArr(arr) {
 var ret = [],
 obj = {},
 i = arr.length,
 l = i,
 n;
 while (--i >= 0) {
  n = Math.floor( Math.random() * l );
  if (obj[n] === void 0) {
   ret[ret.length] = obj[n] = arr[n];
  } else {
   i++;
  }
 }
 return ret;
}

Der obige Code funktioniert, ist jedoch kein guter Algorithmus. Er beabsichtigt, die Schleife „Länge des ursprünglichen Arrays“ auszuführen und dann zu bestimmen, ob der Index vorhanden ist Wenn nicht, fügen Sie den Wert des Index in das neue Array ein. Wenn dies der Fall ist, erhöhen Sie den Dekrementierungsschlüssel i um 1 (der Zweck besteht darin, den Zyklus zu wiederholen, bis ein anderer Index abgerufen wird, der nicht abgerufen wurde). Die Leistung dieser Methode hängt von Ihrem Charakter ab. Ich glaube, dass Schüler, die diese Idee gesehen haben, den Grund verstehen werden.

Geben Sie nun den Algorithmus des Schülers in der Gruppe an:

function randArr(arr) {
 var ret = [],
 i = arr.length,
 n;
 arr = arr.slice(0);
 while (--i >= 0) {
  n = Math.floor( Math.random() * i);
  ret[ret.length] = arr.splice(n, 1)[0];
 }
 return ret;
}

Dies ist ein ziemlich cleverer Algorithmus. Nach jeder Schleife wird ein zufälliger Index genommen und sein Wert aus dem Array gelöscht. Wenn der Index später immer noch zufällig genommen wird, ist der Index nicht mehr der Wert Beim letzten Mal erhalten, nimmt der Bereich der Zufallszahlen entsprechend der Verringerung der Länge des Arrays ab, so dass das ideale Ergebnis durch eine bestimmte Anzahl von Schleifen gleichzeitig erzielt werden kann.

Ich habe auch eine verbesserte Version gesehen, die einige Leistungsprobleme berücksichtigt, die durch den Löschvorgang des Arrays verursacht werden, und den Mischalgorithmus von JK verwendet, dh jeden Löschvorgang in einen Positionsersetzungsvorgang (den abgerufenen Wert) umwandelt Der Index wird mit dem Wert ausgetauscht, der dem aktuellen Dekrementierungsschlüssel i entspricht, sodass die Auswirkungen auf das gesamte Array minimal sind. Geben wir also den Code ein:

function randArr(arr) {
 var ret = [],
 i = arr.length,
 n;
 arr = arr.slice(0);
 
 while (--i >= 0) {
  n = Math.floor( Math.random() * i);
  ret[ret.length] = arr[n];
  arr[n] = arr[i];
 }
 return ret;
}

Schließlich wird eine Methode zum „Erstellen eines Zufallsarrays mit einem Wert zwischen Min und Max“ angegeben. Das Algorithmusprinzip ähnelt dem oben:

function makeRandArr(min, max) {
 var ret = [],
 obj = {},
 n;
 for (; max >= min; max--) {
  n = Math.ceil( Math.random() * (max - min) ) + min;
  ret[ret.length] = obj[n] || n;
  obj[n] = obj[max] || max;
 }
 return ret;
}

Ich hoffe, dass dieser Artikel für das JavaScript-Programmierdesign aller hilfreich sein wird.