「算法」选择排序 快速排序 归并排序 计数排序

总结：
循环需要动手列出表格找规律
递归要用代入法，容易混淆
边界条件的确定
没有处理过长度为 0 和 1 的数组

1. 选择排序

每次取最小值放在数组的最前面

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
        //index是当前最小数的下标
        //index对应的数放在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
}


sort.call(null,[2,5,8])

2. 快速排序

以中间数为基准 ，比他大的排右边，比他小的排左边，然后剔除这个中间数，对左边和右边的这列数组分别进行以此类推的排序

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

quickSort.call(null,[2,5,8])

3. 归并排序

将一组数一分为二 ，二分为四，直到分为单个数组时 ，一个合并成两个，二个合并成四个
两个递归函数

let mergeSort = arr =>{
let k = arr.length
if(k===1){return arr}
//等于1的时候是重点
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.计数排序

主要运用哈希表键值对的形式，遍历数组，键表示数组的元素，值表示出现的次数。
设置 max 最大值
然后遍历哈希表，以 i 从小到大顺序判断是否存在于哈希表中，存在 push 到新的数组里。
注意：对于重复出现的数 另外要做个循环，判断 push 几次

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


countSort([5, 7, 1, 2])

5.统计标签个数

let n = 1
let countNumber = (node) => {
    if (node.children) {

        for (let i = 0; i < node.children.length; i++) {
            n += 1
            countNumber(node.children[i])
        }
    }

    return n
}
let number = countNumber(screen)