JavaScript 四大基础排序算法详解：冒泡、选择、插入与快速排序

作者：半夏时间：2026-10-30 19:32:44浏览：590

本文深入解析JavaScript中四种最常用的基础排序算法：冒泡排序、选择排序、插入排序和快速排序。详细阐述各算法的核心原理、时间复杂度及实现逻辑，并提供完整的JS代码示例，帮助开发者理解并掌握这些基础数据结构操作。

冒泡排序

原理

冒泡排序的核心机制是通过相邻元素之间的条件比较与交换来实现排序，并采用遍历式的方式进行数据调整。何为冒泡？每一次完整的遍历过程被称为一次冒泡。当一次遍历完成后，冒泡排序至少能确保一个元素被移动到其最终的正确位置上。例如：

const arr = [3, 2, 1];
// 第1次冒泡后[2, 1，3] 3移动到正确位置
// 第2次冒泡后[1，2，3] 2移动到正确位置

该算法的实现依赖于两层循环结构：第一层循环用于控制排序的arr.length - 1次迭代。第二层循环负责在每次遍历中处理相邻数据的交换操作，共执行arr.length - 1 - i次，其中i代表第一层循环当前已进行的次数。

代码

export const mySort = arr => {
  for (let i = 0; i < arr.length - 1; i++) {
    // 控制循环次数
    for (let j = 0; j < arr.length - i - 1; j++) {
      // 数据交换
      if (arr[j] > arr[j + 1]) {
        const temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
  return arr;
};

实现array.sort:

export const mySort = (arr, fn) => {
  for (let i = 0; i < arr.length - 1; i++) {
    // 控制循环次数
    for (let j = 0; j < arr.length - i - 1; j++) {
      // 数据交换
      if (fn(arr[j], arr[j + 1])) {
        const temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
  return arr;
};
mySort([1, 5, 3, 8, 2, 4], (a, b) => a > b); //  [1, 2, 3, 4, 5, 8]
mySort([1, 5, 3, 8, 2, 4], (a, b) => a < b); // [8, 5, 4, 3, 2, 1]

选择排序

原理

选择排序通过对数组进行遍历，筛选出符合特定条件（如最大值或最小值）的元素，并将其与数组中对应位置的元素进行交换。何为选择？每一次遍历过程称为一次选择。当一次遍历结束时，会确定一个符合条件的元素并完成位置交换。例如：

const arr = [3, 2, 1];
// 第1次选择后[1, 2，3] 1与3交换位置
// 第2次选择后[1, 2，3]

与冒泡排序不同，选择排序不会频繁执行交换操作，而是在第一层循环结束后，根据条件判断是否需要进行交换。其排序逻辑同样需要两层循环设计：第一层循环控制排序的arr.length - 1次迭代。第二层循环负责寻找需要交换的下标index，此时j = i表示j前面的元素已经排好序。

代码

export const mySort = (arr, fn) => {
  for (let i = 0; i < arr.length - 1; i++) {
    // 控制循环次数
    let index = i;
    for (let j = i; j < arr.length; j++) {
      // 找出下标
      if (fn(arr[j], arr[index])) {
        index = j;
      }
    }
    // 交换数据
    if (index !== i) {
      const copy = arr[index];
      arr[index] = arr[i];
      arr[i] = copy;
    }
  }
  return arr;
};
mySort([9, 5, 3, 4], (a, b) => a > b); // [9, 5, 4, 3]

插入排序

原理

以下内容参考自相关技术文章：@插入排序通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。通常情况下，插入排序采用 in-place 方式在数组上实现：

从第一个元素开始，该元素可以认为已经被排序；
取出下一个元素，在已经排序的元素序列中从后向前扫描；
如果该元素（已排序）大于新元素，将该元素移到下一位置；
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
将新元素插入到该位置后；
重复步骤2~5。

动图展示

冒泡排序

代码

const insertion = arr => {
  const len = arr.length;
  let preIndex;
  let current;
  for (let i = 1; i < len; i++) {
    preIndex = i - 1;
    current = arr[i];
    while (preIndex >= 0 && current < arr[preIndex]) {
      arr[preIndex + 1] = arr[preIndex];
      preIndex--;
    }
    arr[preIndex + 1] = current;
  }
  return arr;
};
insertion([3, 5, 7, 1, 4, 56, 12, 78, 25, 0, 9, 8, 42, 37]);
//  [0, 1, 3, 4, 5, 7, 8, 9, 12, 25, 37, 42, 56, 78]

快速排序

原理

快速排序采用分治法策略，将一个数组划分为两个子数组，随后重复将这两个子数组进一步划分为四个子数组，直至length <= 1。具体思路如下：

从数组中选取一个元素作为“基准”。
重新排序数组，所有比基准值小的元素放置在基准前面（left），所有比基准值大的元素放置在基准后面（right），相同数值的元素可置于任意一侧。分区操作完成后，该基准即处于数列的中间位置。
递归地对小于基准值元素的数组和大于基准值元素的数组进行排序，重复执行1～2步骤。

代码

const quickSort = arr => {
  const len = arr.length;
  if (len <= 1) return arr;
  // 基准
  const num = arr[0];
  // 左右分区
  const left = [];
  const right = [];
  for (let index = 1; index < arr.length; index++) {
    arr[index] <= num ? left.push(arr[index]) : right.push(arr[index]);
  }
  // 递归
  return quickSort(left).concat([num], quickSort(right));
};
console.log(quickSort([3, 2, 6, 8, 99, 2, 3]));// [2, 2, 3, 3, 6, 8, 99]

以上就是详解js中常用4个基础算法的详细内容，更多关于js基础算法的资料请关注本站其它相关文章！

作者最新文章

JavaScript闭包与类(Class)的区别及适用场景对比

2026-11-05 15:48:57

JavaScript入门要学ES6吗？let与箭头函数等新特性解析

2026-11-05 14:49:16

JavaScript 8种数据类型详解：基本类型与引用类型的区别

2026-11-05 14:25:15

怎么在JavaScript中使用async/await优化Ajax异步流程

2026-11-05 13:56:15

JavaScript replace回调函数实现动态正则替换逻辑

2026-11-05 13:52:13