前端一些基础排序算法

1. 冒泡排序

冒泡排序是一种简单的排序算法。它重复地遍历要排序的列表，比较相邻的两个元素，如果它们的顺序错误就交换它们。遍历整个列表的工作会一遍又一遍地进行，直到列表没有再需要交换的元素为止。

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+1];
        arr[j+1] = arr[j];
        arr[j] = temp;
      }
    }
  }
  return arr;
}

var arr = [64, 34, 25, 12, 22, 11, 90];
console.log(bubbleSort(arr)); // [11, 12, 22, 25, 34, 64, 90]插入代码片

冒泡排序的时间复杂度为O(n^2)，其中n是列表的长度。它的空间复杂度为O(1)。在实际应用中，冒泡排序的性能通常比其他排序算法要差，因此很少被使用。

2. 快速排序

快速排序使用分治的思想来将一个大的问题分解成几个小的问题，然后递归地解决这些小问题，最终将它们组合起来得到答案。具体来说，快速排序使用一个元素作为“枢轴”，将列表分成两个子列表，一个子列表所有元素都比枢轴小，另一个子列表所有元素都比枢轴大。然后递归地对两个子列表进行排序。

function quickSort(arr) {
  // 如果数组长度为1或0，则已经有序
  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));
}

// 测试该函数
var arr = [64, 34, 25, 12, 22, 11, 90];
console.log(quickSort(arr));

3. 插入排序

插入排序的基本思想是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增加1的有序表。具体来说，插入排序将列表分成两部分：已排序和未排序。每次取出未排序部分的第一个元素，然后将它插入到已排序部分的正确位置。

function insertionSort(arr) {
  var len = arr.length;
  for (var i = 1; i < len; i++) {
    var key = arr[i]; // 将要插入的元素存储在变量key中
    var j = i - 1; // 从已排序序列的最右边开始比较
    // 将所有比key大的元素向右移动一个位置
    while (j >= 0 && arr[j] > key) {
      arr[j+1] = arr[j];
      j = j - 1;
    }
    arr[j+1] = key; // 将key插入到正确的位置
  }
  return arr;
}

var arr = [64, 34, 25, 12, 22, 11, 90];
console.log(insertionSort(arr));

4. 选择排序

选择排序的基本思想是每次从未排序的部分选出最小的元素，然后将它放到已排序部分的末尾。

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[minIndex]; // 将最小值与当前位置交换
    arr[minIndex] = arr[i];
    arr[i] = temp;
  }
  return arr;
}

var arr = [64, 34, 25, 12, 22, 11, 90];
console.log(selectionSort(arr)); // [11, 12, 22, 25, 34, 64, 90]

了解排序算法的优缺点和适用场景是非常重要的，因为在实际开发中，需要根据实际情况选择最合适的排序算法。不同的排序算法适用于不同的场景，有的算法适用于小规模的数据集，有的算法适用于大规模的数据集，有的算法适用于稳定排序，有的算法适用于不稳定排序，有的算法时间复杂度低，有的算法空间复杂度低，等等。了解这些算法的特点和适用场景可以帮助我们更好地选择算法，提高代码效率和性能。此外，了解排序算法还可以帮助我们更好地理解计算机科学的基本概念和理论，提高我们的编程能力和思维水平。