So sortieren Sie eine Reihe von Zahlen in Javascript nach ihrer Größe

JavaScript ist eine weit verbreitete Programmiersprache, die viele Funktionen in der Webentwicklung, Spieleentwicklung, mobilen Entwicklung und anderen Bereichen implementieren kann. Im eigentlichen Entwicklungsprozess sind Sortieralgorithmen eines der häufigsten Programmierprobleme. Wie sortiere ich mit JavaScript eine Reihe von Zahlen nach ihrer Größe?

JavaScript bietet eine Vielzahl von Sortieralgorithmen, um dieses Problem zu lösen. In diesem Artikel werden mehrere häufig verwendete Sortieralgorithmen vorgestellt.

Bubble Sort

Bubble Sort ist ein einfacher Sortieralgorithmus. Sein Prinzip besteht darin, zwei benachbarte Zahlen zu vergleichen, wenn die Zahl größer ist , vertausche die beiden Zahlen und wiederhole diesen Vorgang, bis alle Zahlen der Größe nach sortiert sind.

Das Folgende ist die JavaScript-Implementierung der Blasensortierung:

function bubbleSort(arr) {
  var len = arr.length;
  for (var i = 0; i < len - 1; i++) {
    for (var j = 0; j < len - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        var temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
  return arr;
}

var arr = [5, 3, 8, 4, 2];
console.log(bubbleSort(arr)); // [2, 3, 4, 5, 8]

Auswahlsortierung

Auswahlsortierung ist ein weiterer einfacher Sortieralgorithmus Suchen Sie dann das kleinste Element im Array, das sortiert werden soll, und platzieren Sie es zuerst. Suchen Sie dann das kleinste Element unter den verbleibenden Elementen und platzieren Sie es der Reihe nach hinter dem sortierten Element, bis alle Elemente angeordnet sind.

Das Folgende ist die JavaScript-Implementierung der Auswahlsortierung:

function selectionSort(arr) {
  var len = arr.length;
  for (var i = 0; i < len - 1; i++) {
    var minIndex = i;
    for (var j = i + 1; j < len; j++) {
      if (arr[j] < arr[minIndex]) {
        minIndex = j;
      }
    }
    var temp = arr[i];
    arr[i] = arr[minIndex];
    arr[minIndex] = temp;
  }
  return arr;
}

var arr = [5, 3, 8, 4, 2];
console.log(selectionSort(arr)); // [2, 3, 4, 5, 8]

Einfügungssortierung

Einfügungssortierung ist ein einfacher und effizienter Sortieralgorithmus bis Die zu sortierenden Elemente werden an der entsprechenden Position in die sortierten Elemente eingefügt. Die Einfügungssortierung ist in zwei Typen unterteilt: direkte Einfügungssortierung und Hill-Sortierung. Im Folgenden stellen wir die Implementierung der direkten Einfügungssortierung vor.

Das Folgende ist die JavaScript-Implementierung der Einfügungssortierung:

function insertionSort(arr) {
  var len = arr.length;
  var preIndex, current;
  for (var i = 1; i < len; i++) {
    preIndex = i - 1;
    current = arr[i];
    while (preIndex >= 0 && arr[preIndex] > current) {
      arr[preIndex + 1] = arr[preIndex];
      preIndex--;
    }
    arr[preIndex + 1] = current;
  }
  return arr;
}

var arr = [5, 3, 8, 4, 2];
console.log(insertionSort(arr)); // [2, 3, 4, 5, 8]

Schnellsortierung

Schnellsortierung ist einer der am häufigsten verwendeten Sortieralgorithmen Prinzip: Die zu sortierenden Elemente werden entsprechend dem Referenzelement in zwei Teile unterteilt. Der linke Teil ist kleiner als das Referenzelement und der rechte Teil ist größer als das Referenzelement. Dann werden der linke und der rechte Teil rekursiv sortiert.

Das Folgende ist die JavaScript-Implementierung der Schnellsortierung:

function quickSort(arr, left, right) {
  var len = arr.length,
    partitionIndex;
  left = typeof left != "number" ? 0 : left;
  right = typeof right != "number" ? len - 1 : right;

  if (left < right) {
    partitionIndex = partition(arr, left, right);
    quickSort(arr, left, partitionIndex - 1);
    quickSort(arr, partitionIndex + 1, right);
  }
  return arr;
}

function partition(arr, left, right) {
  var pivot = left,
    index = pivot + 1;
  for (var i = index; i <= right; i++) {
    if (arr[i] < arr[pivot]) {
      swap(arr, i, index);
      index++;
    }
  }
  swap(arr, pivot, index - 1);
  return index - 1;
}

function swap(arr, i, j) {
  var temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
}

var arr = [5, 3, 8, 4, 2];
console.log(quickSort(arr)); // [2, 3, 4, 5, 8]

Zusammenfassung

Die oben genannten sind mehrere häufig verwendete JavaScript-Sortieralgorithmen, bei denen es sich um Blasensortierung handelt ., Auswahlsortierung, Einfügungssortierung und Schnellsortierung. Im eigentlichen Entwicklungsprozess können je nach Szenario unterschiedliche Sortieralgorithmen ausgewählt werden, um optimale Ergebnisse zu erzielen.

Das obige ist der detaillierte Inhalt vonSo sortieren Sie eine Reihe von Zahlen in Javascript nach ihrer Größe. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!