js排序的时间复杂度_JavaScript实现十大排序算法

一 : 冒泡排序

人们开始学习排序算法时，通常都先学冒泡算法，因为它在所有排序算法中最简单。然而，从运行时间的角度来看，冒泡排序是最差的一个，接下来你会知晓原因

冒泡排序比较所有相邻的两个项，如果第一个比第二个大，则交换它们。元素项向上移动至正确的顺序，就好像气泡升至表面一样，冒泡排序因此得名。

export function bubbleSort(arr: number[]) {

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]) {

;[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]

}

return arr

}

冒泡排序每一轮(外层循环) 会选出一个最小或者最大的数组放到数组最后

所以N 个数字只用选N -1 次 =>外层循环 i

内存循环两两相比, 只用比较 N - 1次 ,但是外层循环已经找到的最值不用比较

所以 => 内层循环 j < arr.length - i -1

一幅图来描述冒泡的工作流程

二：选择排序

选择排序算法是一种原址比较排序算法。他解决了冒泡交换次数过多的毛病,在冒泡排序中需要交换 O(N^2) 次但选择排序中只用交换 O(N)次

选择排序大致的思路是找到数据结构中的最小值并将其放置在第一位，接着找到第二小的值并将其放在第二位，以此类推。

export function selectionSort(arr: number[]) {

let min = 0

for (let i = 0; i < arr.length - 1; i++) {

min = i

for (let j = i + 1; j < arr.length; j++) {

if (arr[j] < arr[min]) {

min = j

}

if (i !== min) {

;[arr[i], arr[min]] = [arr[min], arr[i]]

}

return arr

}

选择排序的代码执行过程如下图

三：插入排序

插入排序的思想十分的重要, 学会了他你才能学习希尔排序,而希尔排序又是排序算法历史上的一个转折点他打破了排序算法时间复杂度平均不会低于 O(N^2) 的理论。

插入排序每次排一个数组项，以此方式构建最后的排序数组。假定第一项已经排序了。接着，它和第二项进行比较——第二项是应该待在原位还是插到第一项之前呢？这样，头两项就已正确排序，接着和第三项比较(它是该插入到第一、第二还是第三的位置呢)，以此类推

export function insertionSort(arr: number[]) {

for (let i = 1; i < arr.length; i++) {

let j = i

let temp = arr[i]

//插入操作 while (j > 0 && arr[j - 1] > temp) {

arr[j] = arr[j - 1]

j--

}

arr[j] = temp

}

return arr

}

插入排序的过程假设数组 [ 3 ,5 , 1, 4, 2]

一开始把 3 当作局部有序 , 把 5 拎出来和局部有序数列比较并插入

// 第一次 : 5 > 3 合理进入下一次循环

// 第二次：把 1 拎出来插入 , 局部有序变为 : [ 3,5 ] 并比较数组变为[1,3,5,4,2]

//第三次 : 把 4拎出来插入 , 局部有序变为 [1,3,5 ] 数组变为 [ 1，3，4，5, 2 ]

// 第四次：把2拎出来插入局部有序变为 [1,3,4,5 ] 数组变为 [ 1,2,3,4,5

//结束循环

四：希尔排序

希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”。

他是第一个将排序算法复杂度降低到 O (N^2)之下的 . 但是他的复杂度至今未被证明猜测效率为 O (N^1.3)

他就是插入排序的一种进阶。只要你会了插入排序你就能写出希尔排序

//复杂度为被证明，猜测为 O (N ^1.3)export function shellSort(arr: number[]) {

//获取增量 let gap = Math.floor(arr.length / 2)

//增量等于1 即为插入排序原始。一定会将数组排好这个时候结束循环 while (gap >= 1) {

//进行插入排序 for (let i = gap; i < arr.length; i++) {

let j = i

let temp = arr[i]

while (j > gap - 1 && arr[j - gap] > temp) {

arr[j] = arr[j - gap]

j -= gap

}

arr[j] = temp

}

//缩小增量 gap = Math.floor(gap / 2)

}

return arr

}

注意：插入排序就是进行 gap(增量) 为 1 时候的操作，

在希尔排序中初始增量为数组长度一半 , 并依次缩小 .这是原版的做法

事实上这个增量有别的计算方式,可以让希尔排序效率更高接近O(N^4/5) 但是他不是我们学习希尔排序的重点 , 关于增量的证明与改进更多是数学方面的知识我们基于面试能够实现基本的希尔排序就可以了 .

五：快速排序

快速排序也许是最常用的排序算法了。它的复杂度为 O(nlog(n))，且性能通常比其他复杂度为 O(nlog(n))的排序算法要好。快速排序使用分而治之的方法 .

快速排序也是二十世纪十大算法之一,感兴趣的朋友可以了解一下

我们重点学习快速排序。

我们先看下阮一峰老师给出的快速排序算法:

function quickSort(arr) {

if (arr.length <= 1) return arr

let left = [],

right = []

//将中间值取除并在arr中移除 let middle = arr.splice(Math.floor(arr.length / 2), 1)[0]

arr.forEach((el) => (el >= middle ? right.push(el) : left.push(el)))

return quickSort1(left).concat(middle, quickSort1(right))

}

例如数组 [ 5, 4 ,3, 2 ,1 ] 先取出中间值 3 => [5,4,2,1]

然后将数组一分为二 => 小于 3 的在左边大于 3 的在右边

=> left [ 2 , 1 ] right[ 5, 4]

=>然后将左右数组递归

=> [2,1] => middle :2 left[ 1 ] right [ ]

=> [5,4 ] => middle :5 left[ 4 ] right [ ]

=>最后依次拼接数组 left+middle +right => [1,2,3,4,5]

注意: 上面的算法使用了 splice 效率非常的差,只是基于快速排序的思想, 写出的比较容易理解的代码我们来看下效率更好的快排是如何做的

export function quickSort(arr: number[]) {

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

return arr

}

function quick(arr: number[], left: number, right: number) {

if (arr.length > 1) {

let index = partition(arr, left, right)

// 两半局部有序分开递归排序分而治之 if (left < index - 1) {

quick(arr, left, index - 1)

}

if (index < right) {

quick(arr, index, right)

}

function partition(arr: number[], left: number, right: number) {

//将数组以pivot 为标准划分为两半局部有序的 let pivot = arr[Math.floor((left + right) / 2)]

let i = left

let j = right

while (i <= j) {

while (arr[i] < pivot) {

i++

}

while (arr[j] > pivot) {

j--

}

if (i <= j) {

swap(arr, i, j)

i++

j--

}

return i

}

function swap(arr: number[], i: number, j: number) {

;[arr[i], arr[j]] = [arr[j], arr[i]]

}

这种实现思路是利用 i j 两个指针 , 将数组以 pivot(枢纽) 分割成两半

左边小于 pivot 右边大于pivot ，然后递归分而治之 .

例如数组 [ 3 , 6 , 5 , 7 , 4 , 1 , 8 , 2 , 9]

选取pivot : 4 ， left ： 3 right : 9

//left 会一直找到 >= 4 时停住

//right 会一直找到<= 4 停住

=> left =>6 , right => 2 这个时候 swap

[3,2,5,7,4,1,8,6,9] 继续循环

=>left =>5 , right =>1 调用 swap

[ 3,2,1,7,4,5,8,6,9]

=>left => 7 , right =>4 调用 swap

[3,2,1,4,7,5,8,6,9] 退出循环 ( i > j )

你会发现在 4 的左边都比 4 小

在 4 的右边都比 4 大 ,这个时候以4 为枢纽分开递归即可

六归并排序

归并排序也是一个可以实际使用的排序算法。归并排序性能不错，其复杂度为 O(nlog(n))。

// JavaScript 的 Array 类定义了一个 sort 函数(Array.prototype.sort)用以排序 JavaScript 数组(我们不必自己实现这个算法)。ECMAScript 没有定义用哪个排序算法，所以浏览器厂商可以自行去实现算法。例如，Mozilla Firefox 使用归并排序作为 Array.prototype.sort 的实现，而 Chrome(V8 引擎)使用了一个快速排序的变体

一张图足以说明归并排序的流程

export function mergeSort(arr: number[]) {

//分而治之 //先分 if (arr.length > 1) {

//将数组分成两半递归进行直到数组长度小于等于 1 let middle = Math.floor(arr.length / 2)

let left = mergeSort(arr.slice(0, middle))

let right = mergeSort(arr.slice(middle, arr.length))

//然后合并排序 arr = merge(left, right)

}

//将结果返回 return arr

}

function merge(left: number[], right: number[]) {

//将左右两个数组合并排序 //i 指向左数组 j 指向右数组 let i = 0

let j = 0

//将结果有序的push 进 result 中 let result = []

while (i < left.length && j < right.length) {

//排序 result.push(left[i] < right[j] ? left[i++] : right[j++])

}

//合并 =>将左右数组剩余的部分 concat return result.concat(i < left.length ? left.slice(i) : right.slice(j))

}

七 : 计数排序

计数排序是一个分布式排序 , 它是用来排序整数的优秀算法(它是一个整数排序算法)，时间复杂度为 O(n+k)，其中 k 是临时计数数组的大小；但是，它确实需要更多的内存来存放临时数组。

这个排序算法的思路就是计数

=> 将每个数当作索引存进数组(count)中，如果重复出现则索引对应的值 ++ ,

这个时候遍历我们的的数组(count) ,他就排好序了。非常的简单

export function countingSort(arr: number[]) {

let count = [] //计数 let result = [] //结果 arr.forEach((el) => {

//将每个数字以索引存入 count中 if (!count[el]) {

count[el] = 0

}

count[el]++

})

count.forEach((el, i) => {

//将count 取出 if (el && el > 0) {

for (let j = 0; j < el; j++) {

result.push(i)

}

})

return result

}

你会发现这个算法只能存储整数且需要消耗大量的空间, 但是在有些时候利用此算法排序非常的好用，比如按照年龄排序, 按照成绩排序 .

即量大范围小(年龄 0 岁~ 150岁) 时非常好用的算法，因为他的效率高 , 因为范围小空间消耗也是可以接受的。

八 : 基数排序

基数排序也是一个分布式排序算法，它是根据关键字排序的。

什么是关键字排序？我们就按数组排序为例 ,他先比较每个数组的个位按计数排序处理, 再比较数组的十位. 计数排序处理 ..... 直到比较完最高位就排好序了.

其实也就是重复进行我们的计数排序 ,来节省空间的浪费

export function radixSort(arr: number[]) {

if (arr.length < 2) {

return arr

}

//找到最大值 let max = -Infinity

arr.forEach((el) => (el > max ? (max = el) : null))

//求他的位数 let digit = (max + '').length

//循环计数排序 let count = []

for (let i = 0; i < digit; i++) {

//按个位排序, 十位排序 ,百位排序 .... arr.forEach((el) => {

let str = el + ''

let temp = +str[str.length - 1 - i]

if (isNaN(temp)) {

temp = 0

}

if (Array.isArray(count[temp])) {

count[temp].push(el)

} else {

count[temp] = [el]

}

})

arr = []

count.forEach((el) => {

if (Array.isArray(el)) {

el.forEach((e) => {

arr.push(e)

})

}

})

count = []

}

return arr

}

九：堆排序

这个我在二叉堆里介绍过了。

十：桶排序

桶排序(也被称为箱排序)也是分布式排序算法，它将元素分为不同的桶(较小的数组)，再使用一个简单的排序算法，例如插入排序(用来排序小数组的不错的算法)，来对每个桶进行排序。然后，它将所有的桶合并为结果数组。

其实上面的计数排序基数排序应该都属于我们的桶排序,

但是桶排序实际用的并不多，我们掌握计数和基数两个变体就好了.

感兴趣的可以去单独了解桶排序 , 看看他为什么用的不多。

十一：总结

然后我又基于随机的数组 (十万个随机数)

,分别进行了上面的排序算法我们来看下他的耗时

你可以发现冒泡简直不能用，等了24秒

最快的计数排序 6 ms 就搞定了。。但是耗费了大量的空间

官方自带的sort 在大部分情况下速度还是慢于我们的快速排序

最后贴上单元测试。

import { createRandomArray } from '../util'

import { bubbleSort } from './01 冒泡排序'

import { selectionSort } from './02 选择排序'

import { insertionSort } from './03 插入排序'

import { shellSort } from './04 希尔排序'

import { quickSort } from './05 快速排序'

import { mergeSort } from './06 归并排序'

import { countingSort } from './07 计数排序'

import { radixSort } from './08 基数排序'

describe('排序算法测试', () => {

test('冒泡排序测试', () => {

const arr = createRandomArray(10)