JavaScript高阶-排序算法

1、冒泡排序

        1.1 功能介绍

        冒泡排序就是简单直观的排序算法，一次比较两个元素，如果前一个比后一个大的话，那这两个元素就进行换位

        1.2 功能分析

1.  比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.  对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素 会是最大的数。
3.  针对所有的元素重复以上的步骤，除了最后一个。
4.  持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

        1.3 代码实现

// var arr = Array.from({ length: 10 }, (_, index) => index + 1).sort(() => 
Math.random() - 0.5)
var arr = [5,4,3,2,1]
// 冒泡排序
function bubbleSort(arr) {
  var arr = [...arr] // 把数组拷贝一份
  for (var i = 0; i < arr.length - 1; i++) {
    // 外层循环的次数
    for (var j = 0; j < arr.length - 1; j++) {
      // 比较时循环的次数
      if (arr[j] > arr[j + 1]) {
        //如果后面比前面大就交换位置
        var temp = arr[j]
        arr[j] = arr[j + 1]
        arr[j + 1] = temp
     }
   }
 }
  return arr
}
console.time('冒泡排序耗时')
console.log('冒泡排序：', bubbleSort(arr))
console.timeEnd('冒泡排序耗时')

        1.4 代码优化

        优化后的代码可以提升代码执行效率

var arr = Array.from({ length: 10 }, (_, index) => index + 1).sort(() => 
Math.random() - 0.5)
// var arr = [5,4,3,2,1]
// 冒泡排序
function bubbleSort(arr) {
  var arr = [...arr] // 把数组拷贝一份
  for (var i = 0; i < arr.length - 1; i++) {
    // 外层循环的次数
    for (var j = 0; j < arr.length - 1 - i; j++) { // 在这里减i
      // 比较时循环的次数
      if (arr[j] > arr[j + 1]) {
        //如果后面比前面大就交换位置
        var temp = arr[j]
        arr[j] = arr[j + 1]
        arr[j + 1] = temp
     }
   }
 }
  return arr
}
console.time('冒泡排序耗时')
console.log('冒泡排序：', bubbleSort(arr))
console.timeEnd('冒泡排序耗时')

2、插入排序

        2.1 功能介绍

        插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在 已排序序列中从后向前扫描，找到相应位置并插入。

        2.2 功能分析

1.  将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序 序列。
2.  从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。

        2.3 代码实现

var arr = [5,4,3,2,1]
function insertionSort(arr) {
  let preIndex, current
  for (let i = 1; i < arr.length; i++) {
    preIndex = i - 1 // 前面的元素
    current = arr[i] // 从第二个元素开始，缓存起来
    while (preIndex >= 0 && arr[preIndex] > current) {// 如果前面假定排好序的元
素大于后面循环的元素
      arr[preIndex + 1] = arr[preIndex] // // 内层循环用于将 preIndex 指向的元素
向后移动，为 current 元素腾出插入位置。
      preIndex-- // 继续与前面比较
   }
    arr[preIndex + 1] = current // 把缓存的元素放在正确位置
 }
  return arr
}
console.time('插入排序耗时')
console.log('插入排序：', insertionSort(arr))
console.timeEnd('插入排序耗时')

3、快速排序

        3.1 功能介绍

        快速排序就是分为三个部分进行排列，有一个基准值，就是中间值，两边分别跟基准值进行比较，前面的部分大的就放到后面，右边与基准值进行比较小的放前面，最后递归实现

        3.2 功能分析

1. 从数列中挑一个元素，作为基准
2. 重新排序数列，比基准值小的放前，大的放后
3. 递归实现，合并前基准和后

        3.3 代码实现

var arr = [5,4,3,2,1]
function quickSort(arr) {
  // 如果数组长度小于或等于1，直接返回数组。
  if (arr.length <= 1) {
    return arr;
 }
  // // 选择数组中间的元素作为基准值（pivot）
  let pivot = arr[Math.floor(arr.length / 2)];
  // 初始化两个数组 left 和 right，用于存放比基准值小和大的元素
  let left = [], right = [];
  // 遍历数组，将元素根据与基准值的比较结果分配到 left 或 right 数组。
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
   }
    if (arr[i] > pivot) {
      right.push(arr[i]);
   }
 }
  // 递归地对 left 和 right 数组进行快速排序，然后将结果与基准值合并并返回。
  return quickSort(left).concat([pivot], quickSort(right));
}
console.time('快速排序耗时')
console.log('快速排序：', quickSort(arr))
console.timeEnd('快速排序耗时')

稳定性：

• 稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序
• 不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序