小知识，大挑战！本文正在参与“程序员必备小知识”创作活动。
数据结构中的排序算法包含很多种，至少包含十多种。根据它们的特性，可以大致分为两种类型：比较类排序和非比较类排序。
- 比较类排序：通过比较来决定元素间的相对次序，其时间复杂度不能突破 O(nlogn)，因此也称为非线性时间比较类排序。比如，交换排序（冒泡排序以及快速排序）、选择排序、插入排序、归并排序。
- 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。比如基数排序、桶排序、基数排序。
冒泡排序
冒泡排序是最基础的排序，一次比较两个元素，如果顺序是错误的就把它们交换过来。重复循环，直到不需要再交换，即该数组已经排序完毕，
var arr = [1, 5, 8, 2, 4, 12, 34, 54, 256, 789, 3, 6, 8]
function bubbleSort(array) {
const len = array.length
if (len < 2) return array
for (let i = 0; i < len; i++) {
for (let j = 0; j < i; j++) {
if (array[j] > array[i]) {
const temp = array[j]
array[j] = array[i]
array[i] = temp
}
}
}
return array
}
bubbleSort(arr) // [1, 2, 3, 4, 5, 6, 8, 8, 12, 34, 54, 256, 789]
快速排序
快速排序的基本思想是通过一趟排序，将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可以分别对这两部分记录继续进行排序，以达到整个序列有序。
var a = [1, 5, 8, 2, 4, 12, 34, 54, 256, 789, 3, 6, 8]
function quickSort(array) {
var quick = function(arr) {
if (arr.length <= 1) return arr
const len = arr.length
const index = Math.floor(len >> 1)
const pivot = arr.splice(index, 1)[0]
const left = []
const right = []
for (let i = 0; i < arr.length; i++) {
if (arr[i] > pivot) {
right.push(arr[i])
} else if (arr[i] <= pivot) {
left.push(arr[i])
}
}
return quick(left).concat([pivot], quick(right))
}
const result = quick(array)
return result
}
quickSort(arr) // [1, 2, 3, 4, 5, 6, 8, 8, 12, 34, 54, 256, 789]
插入排序
插入排序算法描述的是一种简单直观的排序算法。通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入，从而达到排序的效果。
var arr = [1, 5, 8, 2, 4, 12, 34, 54, 256, 789, 3, 6, 8]
function insertSort(array) {
const len = array.length
let current
let prev
for (let i = 1; i < len; i++) {
current = array[i]
prev = i - 1
while (prev >= 0 && array[prev] > current) {
array[prev + 1] = array[prev]
prev--
}
array[prev + 1] = current
}
return array
}
insertSort(arr) // [1, 2, 3, 4, 5, 6, 8, 8, 12, 34, 54, 256, 789]
选择排序
选择排序是一种简单直观的排序算法。首先将最小的元素存放在序列的起始位置，再从剩余未排序元素中继续寻找最小元素，然后放到已排序的序列后面……以此类推，直到所有元素均排序完毕。
var arr = [1, 5, 8, 2, 4, 12, 34, 54, 256, 789, 3, 6, 8]
function selectSort(array) {
const len = array.length
let temp
let minIndex
for (let i = 0; i < len - 1; i++) {
minIndex = i
for (let j = i + 1; j < len; j++) {
if (array[j] <= array[minIndex]) {
minIndex = j
}
}
temp = array[i]
array[i] = array[minIndex]
array[minIndex] = temp
}
return array
}
selectSort(arr) // [1, 2, 3, 4, 5, 6, 8, 8, 12, 34, 54, 256, 789]
归并排序
归并排序是建立在归并操作上的一种有效的排序算法，该算法将已有序的子序列合并，得到完全有序的序列；先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
var arr = [1, 5, 8, 2, 4, 12, 34, 54, 256, 789, 3, 6, 8]
function mergeSort(array) {
const merge = (right, left) => {
const result = []
let il = 0
let ir = 0
while (il < left.length && ir < right.length) {
if (left[il] < right[ir]) {
result.push(left[il++])
} else {
result.push(right[ir++])
}
}
while (il < left.length) {
result.push(left[il++])
}
while (ir < right.length) {
result.push(right[ir++])
}
return result
}
const mergeSort = array => {
if (array.length === 1) { return array }
const mid = Math.floor(array.length / 2)
const left = array.slice(0, mid)
const right = array.slice(mid, array.length)
return merge(mergeSort(left), mergeSort(right))
}
return mergeSort(array)
}
mergeSort(arr) // [1, 2, 3, 4, 5, 6, 8, 8, 12, 34, 54, 256, 789]
各排序算法对比
最后我们来总结下上述几种算法的时间复杂度和空间复杂度。
| 排序算法 | 时间复杂度(平均) | 空间复杂度 | 稳定性 |
|---|---|---|---|
| 冒泡排序 | O() | O(1) | 稳定 |
| 快速排序 | O(nlogn) | O(nlogn) | 不稳定 |
| 插入排序 | O() | O(1) | 稳定 |
| 选择排序 | O() | O(1) | 不稳定 |
| 归并排序 | O(nlogn) | O(n) | 稳定 |
最后说一句
如果这篇文章对您有所帮助，或者有所启发的话，帮忙关注一下，您的支持是我坚持写作最大的动力，多谢支持。
