在 JavaScript 中，排序算法的选择需结合数据规模、有序度等场景，以下是 4种常用排序算法 的实践实现，包含核心逻辑、代码及适用场景。
 
1. 冒泡排序（Bubble Sort）
 
核心逻辑：重复遍历数组，每次比较相邻元素，将较大元素“冒泡”到末尾，直到无交换为止。
特点：简单易理解，稳定排序，但时间复杂度 O(n²)，适合小规模数据。

javascript：
  
function bubbleSort(arr) {
  const len = arr.length;
  // 外层循环控制排序轮次
  for (let i = 0; i < len - 1; i++) {
    let isSwapped = false; // 优化：标记本轮是否有交换，无则数组已有序
    // 内层循环比较相邻元素，每轮后最大元素已在末尾，无需再比较
    for (let j = 0; j < len - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        // 交换相邻元素
        [arr[j[j arr[j + 1]] = [arr[j + 1[j arr[j]];
        isSwapped = true;
      }
    }
    if (!isSwapped) break; // 无交换，直接退出
  }
  return arr;
}

// 测试
console.log(bubbleSort([3, 1, 4, 2])); // 输出：[1, 2, 3, 4]

2. 快速排序（Quick Sort）
 
核心逻辑：选一个“基准值”，将数组分为“小于基准”和“大于基准”的两部分，再递归排序两部分，最终合并。
特点：平均时间复杂度 O(nlogn)，性能优秀，适合中大规模数据；但不稳定，基准值选择影响效率（此处选中间元素优化）。

javascript：
  
function quickSort(arr) {
  // 递归终止条件：数组长度 ≤1 时无需排序
  if (arr.length <= 1) return arr;
  
  const midIndex = Math.floor(arr.length / 2);
  const pivot = arr.splice(midIndex, 1)[0]; // 选中间元素为基准，从原数组删除
  const left = []; // 存储小于基准的元素
  const right = []; // 存储大于基准的元素

  // 遍历剩余元素，分入 left/right
  for (const item of arr) {
    item < pivot ? left.push(item) : right.push(item);
  }

  // 递归排序 left 和 right，再与基准合并
  return [...quickSort(left), pivot, ...quickSort(right)];
}

// 测试
console.log(quickSort([5, 2, 9, 1, 5, 6])); // 输出：[1, 2, 5, 5, 6, 9]

3. 插入排序（Insertion Sort）
 
核心逻辑：将数组分为“已排序区”和“未排序区”，每次从“未排序区”取一个元素，插入“已排序区”的正确位置。
特点：稳定排序，时间复杂度 O(n²)，但对“接近有序”的数据效率极高（接近 O(n)），适合小规模或部分有序数据。
 

javascript：
  
function insertionSort(arr) {
  const len = arr.length;
  // 从第2个元素开始（第1个元素默认在已排序区）
  for (let i = 1; i < len; i++) {
    const current = arr[i]; // 当前要插入的元素
    let j = i - 1; // 已排序区的最后一个元素索引

    // 在已排序区从后向前找，比 current 大的元素后移
    while (j >= 0 && arr[j] > current) {
      arr[j + 1] = arr[j];
      j--;
    }

    // 将 current 插入到正确位置（j+1）
    arr[j + 1] = current;
  }
  return arr;
}

// 测试
console.log(insertionSort([4, 3, 2, 1])); // 输出：[1, 2, 3, 4]

4. 数组内置排序（Array.sort()）
 
核心逻辑：JavaScript 原生方法，不同浏览器实现不同（如 V8 用“快速排序+插入排序”混合策略），默认按“字符串 Unicode 码”排序，需传自定义比较函数。
特点：无需手动实现，性能优化到位，日常开发首选。

javascript：
  
// 1. 数字升序（必须传比较函数，否则会按字符串排序，如 [10,2] 会排错）
const nums = [3, 1, 5, 2];
nums.sort((a, b) => a - b);
console.log(nums); // 输出：[1, 2, 3, 5]

// 2. 数字降序
nums.sort((a, b) => b - a);
console.log(nums); // 输出：[5, 3, 2, 1]

// 3. 对象数组排序（按对象属性排序，如按年龄升序）
const users = [
  { name: "A", age: 25 },
  { name: "B", age: 20 }
];
users.sort((a, b) => a.age - b.age);
console.log(users); // 输出：[{name: "B", age:20}, {name: "A", age:25}]
 

算法选择建议：
 日常开发：优先用  Array.sort() ，兼顾性能和便捷性。
小规模/部分有序数据：插入排序（效率高于冒泡）。
中大规模数据：快速排序（平均性能最优）。
教学/理解基础：冒泡排序（入门首选）。