JS中常用的排序算法

在JS中，常用的排序算法有以下几种：

1. 冒泡排序： 这是一种比较简单的排序算法，在每一轮比较中，将相邻的元素进行比较，如果它们之间的顺序不正确，则交换它们的位置。时间复杂度是O(n^2)。

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

2. 选择排序： 选择排序算法是将数组分成两个部分，第一部分是有序的，第二部分是无序的。每一轮排序中，从无序部分中找到最小的元素，并将其放到有序部分的末尾。时间复杂度也是O(n^2)。

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

3. 插入排序： 插入排序算法是将未排序的元素插入到已排序的部分中。每一轮排序中，取出未排序部分的第一个元素，将它插入到已排序部分的正确位置。时间复杂度也是O(n^2)。

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

4. 快速排序： 快速排序是利用分治的思想，将问题分解成若干个子问题，并解决这些子问题。它的时间复杂度是O(nlogn)。

js
function quickSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  let pivotIndex = Math.floor(arr.length / 2);
  let pivot = arr.splice(pivotIndex, 1)[0];
  let left = [];
  let right = [];
  for (let 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));
}

5. 归并排序： 归并排序算法也是利用分治的思想，将问题分解成若干个子问题，并解决这些子问题。它的时间复杂度同样是O(nlogn)。

js
function mergeSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  let midIndex = Math.floor(arr.length / 2);
  let left = arr.slice(0, midIndex);
  let right = arr.slice(midIndex);
  return merge(mergeSort(left), mergeSort(right));
}
 function merge(left, right) {
  let result = [];
  let leftIndex = 0;
  let rightIndex = 0;
  while (leftIndex < left.length && rightIndex < right.length) {
    if (left[leftIndex] < right[rightIndex]) {
      result.push(left[leftIndex]);
      leftIndex++;
    } else {
      result.push(right[rightIndex]);
      rightIndex++;
    }
  }
  return result.concat(left.slice(leftIndex), right.slice(rightIndex));
}

这些算法各有优缺点，可以根据数据的大小和数据的特点选择适合的排序算法。在实际应用中，常用的排序算法有快速排序和归并排序，因为它们的时间复杂度相对比较低，而且对于大规模的数据排序效果比较好。