1. 选择排序

时间复杂度：O(n^2)

• 递归写法

let min = (numbers)=>{
    if(numbers.length>2){
        return min([numbers[0],min(numbers.slice(1))])
    }else{
        return Math.min.apply(null,numbers)
    }
} //找到数组中最小的数

let minIndex = (numbers)=>numbers.indexOf(min(numbers))//得到最小的数的index

let sort = (numbers) =>{
    if(numbers.length > 2){
        let index = minIndex(numbers)
        let min = numbers[index]
        numbers.splice(index,1)
        return [min].concat(sort(numbers))
    }else{
        return numbers[0]<numbers[1]?numbers:numbers.reverse()
    }
}//选择排序的实现！

• 循环写法

let swap = (array,i,j) => {
    let temp = array[i] //将作比较的两个数的其中一个给第三者
    array[i] = array [j]
    array[j] = temp //两个数位置交换
}
let minIndex = (numbers) =>{
    let index = 0
    for(let i = 1; i < numbers.length; i++){
        if(numbers[i] < numbers[index]){
            index = i
        }
    }
    return index
} //找到最小数的index
let sort = (numbers) => {
    for(let i = 0; i < numbers.length - 1; i++){
        let index = minIndex(numbers.slice(i)) + i
        if(index !== i){
            swap(numbers,index,i)
        }
    }
    return numbers
}

2. 快速排序

时间复杂度：O(log2 n)

let quickSort = arr => {
    if (arr.length <= 1) { return arr; } //数组为空或者只有一位的情况
    let pivotIndex = Math.floor(arr.length / 2); //取数组中间某个数的index
    let pivot = arr.splice(pivotIndex, 1)[0]; //根据index得到中间的数
    let left = [];
    let right = [];  
    for (let i = 0; i < arr.length; i++){
        if (arr[i] < pivot) { 
        left.push(arr[i]) //小于中间数的放左边
        } else { 
        right.push(arr[i]) //大于的放右边
        }
    }
    return quickSort(left).concat([pivot], quickSort(right) ) //将得到排好序的数组连接起来
}

3. 归并排序

时间复杂度：O(log2 n)

let mergeSort = arr =>{
    let k = arr.length
    if(k === 1){return arr}
    let left = arr.slice(0, Math.floor(k/2))
    let right = arr.slice(Math.floor(k/2))
    //将数组分为左右两部分，最终会被拆到数组内只剩一个数，在进行比较
    return merge(mergeSort(left), mergeSort(right))
}
let merge = (a, b) => {
    if(a.length === 0) return b
    if(b.length === 0) return a
    return a[0] > b[0] ?[b[0]].concat(merge(a, b.slice(1))) :[a[0]].concat(merge(a.slice(1), b))
}

4. 计数排序

时间复杂度：O(n + max)

let countSort = arr =>{
    let hashTable = {}, max = 0, result = [] //初始化哈希表，最大值
    for(let i = 0; i < arr.length; i++){ 
        if(!(arr[i] in hashTable)){
            hashTable[arr[i]] = 1
        }else{
            hashTable[arr[i]] += 1
        }
        if(arr[i] > max) {max = arr[i]} //最大值一直给max
    }
    for(let j = 0; j <= max; j++){ // 设置最小值为0，遍历哈希表
        if(j in hashTable){
            for(let i = 0; i < hashTable[j]; i++){ //i < hashTabl[j] 一个数多次出现，都要放进数组里 
                result.push(j)//如果数在表里面，则将数放进创建的数组里面
            }
        }
    }
    return result
}