JS 数组常用的几种排序方式

前言

排序是对数组施加的最常用的算法，所谓排序就是将数组中的元素，按照从小到大或者从大到小的顺序重新排列。常见的一些方法有 sort() ， 快速排序 ，冒泡排序 ，选择排序 ， 插入排序 ，希尔排序等。

sort()

ES6提供的数组排序方法，使用也很简单。

js 复制代码

let arr = [1, 3, 2, 10, 5, 9, 7, 9, 1, 2, 1]
let result = arr.sort((a,b) => {
  return a - b // 从小到大
  // return b - a
})
console.log('[result]', result)
// [result] (11) [1, 1, 1, 2, 2, 3, 5, 7, 9, 9, 10]

快速排序

快排的话，主要的一个思想是：找出数组中间的项，通过创建leftArr，rightArr两个空数组；比中间项大的放rightArr，小的leftArr，然后对这两个数组进行递归操作，重复上面的操作，直至把需要排序的数组的每一个元素都处理为length为1的rightArr 或 leftArr。

js 复制代码

let arr = [1, 3, 2, 10, 5, 9, 7, 9, 1, 2, 1]
Array.prototype.quickSort = function() {
  const rec = (argArr) => {
    if(argArr.length < 2) return argArr
    let centerIndex = Math.floor(argArr.length / 2)
    let centerValue = argArr.splice(centerIndex, 1)[0]
    let leftArr = []
    let rightArr = []
    for(let i = 0; i < argArr.length; i++) {
      if(argArr[i] < centerValue) leftArr.push(argArr[i])
      else rightArr.push(argArr[i]
    }
    return rec(leftArr).concat(centerValue, rec(rightArr))
  }
  return rec(JSON.parse(JSON.stringify(this)))
}
console.log('[quickSort]', arr.quickSort())
// [quickSort] (11) [1, 1, 1, 2, 2, 3, 5, 7, 9, 9, 10]

冒泡排序

冒泡排序的基本思想是：通过相邻元素的比较和交换来将较大（或较小）的元素逐渐"冒泡"到数组的一端，通过缩小遍历范围，最终完成排序。

js 复制代码

let arr = [1, 3, 2, 10, 5, 9, 7, 9, 1, 2, 1]
Array.prototype.bubbleSort = function() {
  const rec = (argArr) => {
    if(argArr.length < 2) return argArr
    for(let i = 0; i < argArr.length - 1; i++) { // 需要比较的轮数
      for(let j = 0; j < argArr.length - 1 - i; j++) { // 每轮比较的次数
        if(argArr[j] > argArr[j + 1]) {
          // 交换位置
          let temp = argArr[j + 1]
          argArr[j + 1] = argArr[j]
          argArr[j] = temp
        }
      }
    }
    return argArr
  }
  return rec(JSON.parse(JSON.stringify(this)))
}
console.log('[bubbleSort]', arr.bubbleSort())
// [bubbleSort] (11) [1, 1, 1, 2, 2, 3, 5, 7, 9, 9, 10]

选择排序

选择排序的的核心思想在于：依次取一个元素与剩下所有元素进行比较，符合条件，交换位置。每次从未排序的元素中选择最小（或最大）的元素，放到已排序部分的末尾，从而实现排序。

js 复制代码

let arr = [1, 3, 2, 10, 5, 9, 7, 9, 1, 2, 1]
Array.prototype.SelectSort = function() {
  const rec = (argArr) => {
    if(argArr.length < 2) return argArr
    for (let i = 0; i < argArr.length - 1; i++) {
      let minIndex = i // 取每一项与剩下元素比较
      // 寻找最小的元素 并 交换位置
      for (let j = i + 1; j < argArr.length; j++) {
        if (argArr[j] < argArr[minIndex]) {
          let temp = argArr[i];
          argArr[minIndex] = argArr[j];
          argArr[j] = temp;
        }
      }
    }
    return argArr
  }
  return rec(JSON.parse(JSON.stringify(this)))
}
console.log('[SelectSort]', arr.SelectSort())
// [SelectSort] (11) [1, 1, 1, 2, 2, 3, 5, 7, 9, 9, 10]

插入排序

插入排序可认为是对冒泡排序的优化。思想：把整个数组视为两部分，一部分是有序，另一部分无序，将无序的每一项插入到有序的相应位置。

js 复制代码

let arr = [4, 3, 2, 10, 5, 9, 7, 9, 1, 2, 1]
Array.prototype.insertionSort = function() {
  const rec = (argArr) => {
    if(argArr.length < 2) return argArr
    for (let i = 1; i < argArr.length; i++) { // 无序
      let index = i
      for (let j = i - 1; j >= 0; j--) { // 有序
        if (argArr[index] < argArr[j]) {
          [argArr[index], argArr[j]] = [argArr[j], argArr[index]]
          index--
        }
      }
    }
    return argArr
  }
  return rec(JSON.parse(JSON.stringify(this)))
}
console.log('[insertionSort]', arr.insertionSort())
// [insertionSort] (11) [1, 1, 2, 2, 3, 4, 5, 7, 9, 9, 10]

希尔排序

一种更高效的插入排序，与插入排序相比减少比较和移动的次数。先将整个无序序列分割成为若干子序列，分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。

js 复制代码

let arr = [4, 3, 2, 10, 5, 9, 7, 9, 1, 2, 1]
Array.prototype.shellSort = function() {
  const rec = (argArr) => {
    if(argArr.length < 2) return argArr
    let arrLength = argArr.length;
    for (let gap = Math.floor(arrLength / 2); gap > 0; gap = Math.floor(gap / 2)) {
      for (let i = gap; i < arrLength; i++) {
        let j = i;
        let temp = argArr[i];
        while (j - gap >= 0 && argArr[j - gap] > temp) {
          argArr[j] = argArr[j - gap];
          j = j - gap;
        }
        argArr[j] = temp;
      }
    }
    return argArr
  }
  return rec(JSON.parse(JSON.stringify(this)))
}
console.log('[shellSort]', arr.shellSort())