JavaScript 几种排序算法实现（冒泡、选择、插入、归并、快速排序）

最新推荐文章于 2025-09-05 11:22:47 发布

转载最新推荐文章于 2025-09-05 11:22:47 发布 · 77 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/mykiya/p/11006708.html

文章标签：

#javascript #数据结构与算法 #ViewUI

本文深入探讨了五种常见的排序算法：冒泡排序、选择排序、插入排序、归并排序和快速排序。每种算法都附有详细的实现代码，帮助读者理解其工作原理和效率特点。

1. 冒泡

// 冒泡 - 每次循环, 将两两中偏大的元素移动到右边
for (let i = 0; i < arr.length - 1; i++) {
  for (let j = i; j < arr.length; j++) {
    if (arr[i] > arr[j]) {
      [arr[i], arr[j]] = [arr[j], arr[i]]
    }
  }
}
console.log(arr)

2. 选择排序

选择排序算法是一种原址比较排序算法。选择排序大致的思路是找到数据结构中的最小值并将其放置在第一位，接着找到第二小的值并将其放在第二位。

// 选择 - 找到最小的, 放在第一位; 找到第二小的, 挡在第二位
for (let i = 0; i < arr.length; i++) {
  let min_index = i;
  for (let j = i; j < arr.length; j++) {
    if (arr[min_index] > arr[j]) {
      min_index = j
    }
  }
  if (i !== min_index) {
    [arr[i], arr[min_index]] = [arr[min_index], arr[i]]
  }
}
console.log(arr)

3. 插入排序

// 插入 - 找到合适的位置, 把它插进去
for (let i = 0; i < arr.length; i++) {
  let j = i;
  let tmp = arr[i]
  while (j > 0 && arr[j - 1] > tmp) {
    arr[j] = arr[j - 1];
    j--;
  }
  arr[j] = tmp;
}
console.log(arr)

4. 归并排序

// 归并 - 采用分治思想, 将原数组分成只有一个位置的小数组, 接着讲小数组归并成大数组
let mergeSortRec = function (arr) {
  let length = arr.length;
  if (length === 1) {
    return arr;
  }

  let mid = Math.floor(length / 2);
  let left_array = arr.slice(0, mid);
  let right_array = arr.slice(mid, length);

  return merge(mergeSortRec(left_array), mergeSortRec(right_array));
}

let merge = function (left_array, right_array) {
  let result = [];
  let il = 0;
  let ir = 0;

  while (il < left_array.length && ir < right_array.length) {
    if (left_array[il] < right_array[ir]) {
      result.push(left_array[il++])
    } else {
      result.push(right_array[ir++])
    }
  }
  while (il < left_array.length) {
    result.push(left_array[il++])
  }
  while (ir < right_array.length) {
    result.push(right_array[ir++])
  }
  return result;
}
console.log(mergeSortRec(arr))

5. 快速排序

// 快排 - 采用分治思想, 划分主元
let quick = function (arr, left_ptr, right_ptr) {
  let index;
  if (arr.length > 1) {
    // 划分主元, 并执行交换
    index = partition(arr, left_ptr, right_ptr);
    if (left_ptr < index - 1) {
      quick(arr, left_ptr, index - 1);
    }
    if (index < right_ptr) {
      quick(arr, index, right_ptr);
    }
  }
}
let partition = function (array, left_ptr, right_ptr) {
  let pivot = array[Math.floor((left_ptr + right_ptr) / 2)];
  let i = left_ptr;
  let j = right_ptr;

  while (i <= j) {
    while (array[i] < pivot) {
      i++;
    }
    while (array[j] > pivot) {
      j--;
    }
    if (i <= j) {
      [aarrayrr[i], array[j]] = [array[j], array[i]];
    }
    i++;
    j--;
  }
  return i;
}

quick(arr, 0, arr.length - 1)
console.log(arr)