选择排序（每次选择最小/大的，选完就排完）

• 复习代码： 总结：每次找到最小的数放前面，然后对后面的数做同样的事情。

let minIndex = (numbers) => 
    numbers.indexOf(min(numbers)) 
let min = (numbers) =>{ 
    if(numbers.length > 2) { 
       return min( 
         [numbers[0], min(numbers.slice(1))] ) 
    }else{ 
       return Math.min.apply(null, numbers) 
    } 
  }
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()
    }
}

选择排序的循环写法

• 永远有两种写法： 递归和循环

• 目前的minIndex(缺点：看着繁琐)

let minIndex = (numbers) => {
    numbers.indexOf(min(numbers)) 
let min = (numbers) =>{ 
     return min( 
         [numbers[0], min(numbers.slice(1))] 
     ) 
 }

• 重写后的代码

let minIndex = (numbers) =>{
    let index = 0
for(let i = 1; i<numbers.length; i++){
    if(numbers[i] < numbers[index]){
        index = i
    }
}
    return index
}

所有的递归都可以改成循环

把sort改写一下（递归变循环）

• 思路：每次找到最小的数放前面，然后i++

实现swap

let swap = (array, i, j) =>{
    let temp = array[i]
    array[i] = array[j]
    array[j] = temp 
}
swap(numbers, 1, 2)

• 运用析构赋值

分析代码

• 问题一： i<??? 应该写什么？

如果直接写i<numbers.length，假设numbers的长度为n, n = 4, i = 3时，index就没有取值。所有i<numbers.length - 1

• 问题二：

let index = minIndex(numbers.slice(i)) + i 意思为找到最小数字的下标：范围是numbers.slice(i)，然后得到的下标，加上i,然后这个i是当前数组最小数字的下标

• 最终代码

let sort = (numbers) =>{
    for(let i = 0; i<numbers.length - 1; i++){
        console.log(`----`) //这个log很精髓
        console.log(`i: ${i}`)
        let index = minIndex(numbers.slice(i)) + i
        console.log(`index: ${index}`)
        console.log(`min: ${numbers[index]}`)
        if(index!== i){
            swap(numbers,index,i)
            console.log(`swap ${index}: ${i}`)
            console.log(numbers)
        }
    }
    return numbers
}
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
}

• 所有递归都能改成循环

• 循环的时候有很多细节:这些细节很难想清楚;要动手列出表格找规律;尤其是边界条件很难确定;我们没有处理长度为 0 和 1 的数组

• 如果 debug: 学会看控制台; 学会打 log; 打 log 的时候注意加标记

快速排序

let quickSort = arr => {
    if(arr.length <= 1) {
        return arr }
    let pivotIndex = Math.floor(arr.length / 2)
    let pivot = arr.splice(pivotIndex, 1)[0]
    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))
}

归并排序

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))
}

计数排序

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]}
    }
    for(let j=0; j<=max; j++){
        if(j in hashTable){
            for(let i = 0; i<hashTable[j]; i++){
                resilt.push(j)
            }
            
        }
    }
    return result
}

计数排序的特点

数据结构不同

• 使用了额外的 hashTable

• 只遍历数组一遍（不过还要遍历一次 hashTable）

• 这叫做「用空间换时间」

时间复杂度对比

• 选择排序 O(n^2)

• 快速排序 O(n log2 n)

• 归并排序 O(n log2 n)

• 计数排序 O(n + max)