快速排序

思想：

对一个数组找到一个中间数，左右分两组，创建两个空数组，遍历左右数组，如果比中间数大放在右边数组，比中间数小就放在左边数组，采用递归，最后将两个数组和中间作比较的数合成一个新的数组 代码示例

let quickSort = (numbers) =>{
    if(numbers.length <= 1){return numbers}
    let pivot = numbers.splice(Math.floor(numbers.length / 2),1)[0]
    let left = []
    let right = []
    for (let i = 0;i<numbers.length;i++){
        if(numbers[i]<pivot){
            left.push(numbers[i])
        }else{right.push(numbers[i])}
    }
    return quickSort(left).concat([pivot], quickSort(right))
}

归并排序

思想：

和快速排序相似，只是说没有找中间量做对比，将原数组分成两个数组，从两个数组里找到第一个数作比较，小的放在第一个，递归到最后一个，最后返回排序完成的数组

代码示例

let mergeSort = (numbers) =>{
    if (numbers.length<=1){return numbers}
    let left = numbers.slice(0,Math.floor(numbers.length/2))
    let right = numbers.slice(Math.floor(numbers.length/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))
}

计数排序

思想:

创建一个哈希表，和一个新数组，遍历一遍原数组，放进哈希表里，遍历哈希表，从小到大放进新数组里，返回新数组

代码示例：

let countSort = (numbers) =>{
    let hashTable ={},max =0,result = []
    for(let i =0 ;i<numbers.length;i++){
        if(!(numbers[i] in hashTable)){
            hashTable[numbers[i]] = 1
        }else(hashTable[numbers[i]] += 1)
    }
    if (numbers[i]>max){max =numbers[i]}
    for(let j = 1;j<max;j++){
        if(j in hashTable){
            for(let i =0 ;i<hashTable[j];j++){
                result.push(j)
            }
        }
    }
    return result
}

冒泡排序

思想：

遍历数组，找到第一个和后一位对比，如果比他大就交换位置，如果比它小就保持不动。后一位重复原先行为，直至数组排序完成

代码示例：

let bubbleSort = (numbers) =>{
for(let j = 0 ; j <numbers.length-1;j++){
    for(let i =1;i<numbers.length-1-j;i++){
        if(numebrs[i] > numbers[i+1]){
            let item = numbers[i]
            numbers[i] = numbers[i=1]
            numbers[i+1] = item
        }
    }
  }
  return nubmers
}

总结

时间复杂度

• 快速排序 (n*log2n)
• 归并排序(n*log2n)
• 计数排序(n*max)
• 冒泡排序(n^2)