Comment trier un ensemble de nombres par ordre de taille en javascript

JavaScript est un langage de programmation largement utilisé qui peut implémenter de nombreuses fonctions dans le développement Web, le développement de jeux, le développement mobile et d'autres domaines. Dans le processus de développement actuel, les algorithmes de tri sont l'un des problèmes de programmation courants. Comment utiliser JavaScript pour trier un ensemble de nombres par ordre de taille ?

JavaScript fournit une variété d'algorithmes de tri pour résoudre ce problème. Cet article présentera plusieurs algorithmes de tri couramment utilisés.

Tri à bulles

Le tri à bulles est un algorithme de tri simple. Son principe est de comparer deux nombres adjacents si le nombre précédent est plus grand que le nombre suivant, échangez les deux nombres et répétez ce processus jusqu'à ce que tous les nombres soient dans l'ordre. de taille.

Ce qui suit est l'implémentation JavaScript du tri à bulles :

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]

Tri par sélection

Le tri par sélection est un autre algorithme de tri simple, son principe est de trouver le plus petit élément du tableau à trier et de le placer en premier, puis de trouver le. le plus petit élément parmi les éléments restants et placez-le tour à tour derrière les éléments triés jusqu'à ce que tous les éléments soient disposés.

Voici l'implémentation JavaScript du tri par sélection :

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]

Tri par insertion

Le tri par insertion est un algorithme de tri simple et efficace. Son principe est d'insérer les éléments à trier aux positions appropriées parmi les éléments triés. Le tri par insertion est divisé en deux types : le tri par insertion directe et le tri Hill. Ci-dessous, nous présenterons la mise en œuvre du tri par insertion directe.

Voici l'implémentation JavaScript du tri par insertion :

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]

Tri rapide

Le tri rapide est l'un des algorithmes de tri les plus couramment utilisés. Son principe est de diviser les éléments à trier en deux parties selon l'élément de base, et la partie gauche est plus petite que l'élément de base, la partie droite est plus grande que l'élément de base, puis les parties gauche et droite sont triées de manière récursive.

Ce qui suit est l'implémentation JavaScript du tri rapide :

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]

Résumé

Ci-dessus sont plusieurs algorithmes de tri JavaScript couramment utilisés, qui sont le tri à bulles, le tri par sélection, le tri par insertion et le tri rapide. Dans le processus de développement actuel, différents algorithmes de tri peuvent être sélectionnés selon différents scénarios pour obtenir des résultats optimaux.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!