Node.js 中的排序算法 - JavaScript

排序算法是在计算机科学中经常会遇到的问题。它们是一组将元素按照特定规则或特定属性进行排序的算法。在本文中，我们将讨论在 Node.js 中可用的一些常见的排序算法。

冒泡排序

冒泡排序是一种简单的排序算法，它重复地遍历要排序的列表，比较每对相邻的项目，并在必要时交换它们的位置。在这个过程中，每个项都会通过相邻的比较逐渐“上升”到其最终位置。

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

选择排序

选择排序是一种简单的排序算法，它的主要思想是，找到数组中最小的元素，将其放到数组的最前面，然后继续找到数组中剩余元素中最小的元素，放到已排序序列的末尾。重复这个过程，直到排序完成。

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

插入排序

插入排序是一种简单的排序算法，它的过程是将未排序的元素一个一个插入到已排序的部分中。它类似于整理纸牌时，抓一张牌，然后将其放到合适的位置。

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;
}

快速排序

快速排序是一种高效的递归排序算法，它的主要思想是选定一个基准元素，将数组分成两个子数组，一个子数组中的元素都比基准元素小，另一个子数组中的元素都比基准元素大。然后对这两个子数组递归地执行相同的操作，直到所有子数组都变成只有一个元素的数组，并根据递归的返回值进行合并。

function quickSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  var pivotIndex = Math.floor(arr.length / 2);
  var pivot = arr.splice(pivotIndex, 1)[0];
  var left = [];
  var right = [];
  for (var i = 0; i < arr.length; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }
  return quickSort(left).concat([pivot], quickSort(right));
}

归并排序

归并排序是一种高效且普适性较强的排序算法，它的主要思想是将待排序的序列分成若干个子序列，每个子序列都是有序的。然后将这些有序的子序列合并成一个有序的序列。

function mergeSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  var mid = Math.floor(arr.length / 2);
  var left = arr.slice(0, mid);
  var right = arr.slice(mid);
  return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right) {
  var result = [];
  var il = 0;
  var ir = 0;
  while (il < left.length && ir < right.length) {
    if (left[il] < right[ir]) {
      result.push(left[il++]);
    } else {
      result.push(right[ir++]);
    }
  }
  return result.concat(left.slice(il)).concat(right.slice(ir));
}

以上是一些在 Node.js 中可用的常见的排序算法。在实际应用中，需要根据具体的需求选择最适合的排序算法。