JavaScript实现几种排序算法

JavaScript实现几种排序算法

图片名词解释：
n: 数据规模
k:“桶”的个数
In-place: 占用常数内存，不占用额外内存
Out-place: 占用额外内存

（图片源自网络，侵删）

1.冒泡排序：

function bubbleSort(arr){
var temp
for(var i = 1; i < arr.length; i++){
for(var j = 0; j < arr.length-1-i; j++){//每一趟都会把最大的放到最后，因此循环-1
if(a[j] > a[j+1]){
temp = a[j]
a[j] = a[j+1]
a[j+1] = temp
}
}
}
return arr
}

2.选择排序

function selectSort(arr){
for(var i = 1; i < arr.length; i++){
let t = arr[i]
for(var j = i - 1; j >= 0; j--){
if(t < arr[j]){
arr[j+1] = arr[j]
arr[j] = t
}
else
break
}
}
return arr
}

3.希尔排序（插排就是将希尔排序中的gap设为1， 因此不再写出）

function shellSort(arr){
for(var gap = 4; gap > 0; gap /= 2){
// 以gap为间隔进行插入排序
for(var i = gap; i < arr.length; i++){
let t = arr[i]
for(var j = i - gap; j >= 0; j -= gap){
if(t < arr[j]){
arr[j + gap] = arr[j]
arr[j] = t
}
else break
}
}
}
return arr

4.归并排序

// 归并排序中的——治
// 解释各参数的意思：
// arrB为待排序列， arrN为临时序列， lHead表示左边起始的排序位置， rHead表示右边起始的排序位置，rEnd表示结束位置
function Merge(arrB, arrN, lHead, rHead, rEnd){
let lEnd = rHead - 1 //假设两个序列紧靠在一起， 这里的指针通通以数组下标来表示
let arrBNum = rEnd - lHead + 1 //确定代排序列的长度
let i
for(i = lHead; lHead <= lEnd && rHead <= rEnd; i++){
if(arrB[lHead] <= arrB[rHead]){
arrN[i] = arrB[lHead]
lHead++
}else{
arrN[i] = arrB[rHead]
rHead++
}
}
while(lHead <= lEnd){
//排完序左边还有多余的直接插入到arrN的后面
arrN[i] = arrB[lHead]
i++
lHead++
}
while(rHead <= rEnd){
//排完序左边还有多余的直接插入到arrN的后面
arrN[i] = arrB[rHead]
i++
rHead++
}
// 将临时数组arrN中的值按照次序复制给arrB对应位置
for(var j = 0; j < arrBNum; j++, rEnd--){
arrB[rEnd] = arrN[rEnd]
}
return arrB

}

// 归并排序中的——分（递归）
function Sort(arrB, arrN, lHead, rEnd){
var mid
if(lHead < rEnd){
mid = parseInt((rEnd + lHead)/2)
// console.log(mid + "==" + rEnd + "==" + lHead)
// 循环调用Sort函数对左右两边进行排序
Sort(arrB, arrN, lHead, mid)  //排左边， 一直递归到 lHead = rEnd (即针对只有1个数据的merge)
Sort(arrB, arrN, mid+1, rEnd)
// 排序方法，递归调用的最后一步就是将他们排序
Merge(arrB, arrN, lHead, mid+1, rEnd)
}
return arrB
}

// 合并
function mergeSort(arr){
var arrN = []
return Sort(arr, arrN, 0, arr.length-1)
}

5.快速排序

function quickSort (arr, start, end){
if(start > end) return
let base = arr[start]
let l = start
let r = end
while(l != r){
while(arr[r] >= base && l < r){
r--
}//从右向左寻找，直到有数比基准数小时，停下
while(arr[l] <= base && l < r){
l++
}//从左向右寻找，直到有数比基准数大时，停下

// 此时交换找到的这两个数
var temp = arr[r]
arr[r] = arr[l]
arr[l] = temp
}
//此时循环被跳出说明此时 l==r 则需要交换其与基准数的位置
// arr[l] = base
// arr[start] = arr[r]  这样赋值是错误的，因为arr[i] 和arr[r] 是指向的同一个数，修改一个则另一个也会改变
arr[start] = arr[l]
arr[l] = base

// 此时位于arr[r]左边的数都比他小，右边的数都比他大
// 对它的左右两边分别进行快排
quickSort(arr, start, l-1)
quickSort(arr, r+1, end)

return arr

}

6.堆排序

//堆排序

function heapify(arr, n, i){
if(i >= n){
return
}
let c1 = 2*i + 1
let c2 = 2*i + 2 //找到左右子节点, 这里一定要记得对左右子节点的存在性进行判断不能越界

var max = i
if(arr[c1] > arr[max] && c1 < n){
max = c1
}
if(arr[c2] > arr[max] && c2 < n){
max = c2
}
if(max != i){
var temp = arr[i]
arr[i] = arr[max]
arr[max] = temp
heapify(arr, n, max) //每次交换后要对被交换的孩子节点进行重新调整
}  //堆顶放上最大元素

return arr
}

function bulid_heap(arr, n){
//构造一个堆一定要从下往上
let last_node = n-1
let parent = parseInt((last_node - 1)/2)

for(var i = parent; i >= 0; i--){
heapify(arr, n, i)
}
return arr
}

function heapSort(arr, n){
bulid_heap(arr, n)
for(var i = n - 1; i >= 0; i--){
var temp = arr[i]
arr[i] = arr[0]
arr[0] = temp
// console.log(i+'--'+arr)
bulid_heap(arr, i)
// console.log(arr)
// console.log(i + "-" + arr[i])
}
return arr
}

以上7种（含插入排序）都是基于选择的简单排序

下面是非比较的排序算法（就叫 桶排序吧~）
1.计数排序

// 计数排序

function countSort (arr, min, max){
let count = []
for(var i = min; i <= max; i++){
count[i] = 0
}//对JS的数组进行初始化，否则会显示未定义而出错
let result = []

for(var i = 0; i < arr.length; i++){
// console.log(arr[i])
count[arr[i]]++
console.log(count[arr[i]])
}
console.log(count)
for(var j = min, index = 0; j<= max; j++){
while(count[j] != 0){
result[index] = j
index++
count[j]--
}
}
return result
}

未完待续……