数组排序

选择排序

实现思路：不断的选出数组中的最小值，并移除最小值，直到数组长度小于2为止

let selectSort = arr => {
    let minNum = arr => {
        if (arr.length < 2) return arr
        let min = arr[0]
        for (let i = 0; i < arr.length; i++) {
            if (arr[i] < min) min = arr[i]
        }
        return min
    }
    if (arr.length > 2) {
        let min = minNum(arr)
        let index = arr.indexOf(min)
        arr.splice(index, 1)
        return [min].concat(selectSort(arr))
    } else {
        return arr[0] > arr[1] ? arr.reverse() : arr
    }
}

快速排序

实现思路：二分法，不断选取中位数，将比中位数小的数放进数组left[]，比中位数大的放入right[]，直到数组的长度小于等于1为止

let quickSort = arr => {
    if (arr.length <= 1) return arr
    let index = Math.floor(arr.length / 2)
    let numMid = arr.splice(index, 1)[0]
    let left = [], right = []
    for (let i = 0; i < arr.length; i++) {
        arr[i] > numMid ? right.push(arr[i]) : left.push(arr[i])
    }
    return quickSort(left).concat([numMid], quickSort(right))
}

归并排序

实现思路：不断的将数组分为到两两组合的数组，选出数组中的最小值

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

计数排序

实现思路：将整数数组循环，存入到哈希表中，key存值，value存值出现的次数，获取数组中的最小值和最大值作为循环的范围，通过循环下标进行排序

let countSort = arr => {
    let rs = [], hashTable = {}, min = 0, max = 0
    for (let i = 0; i < arr.length; i++) {
        (arr[i] in hashTable) ? hashTable[arr[i]] += 1 : hashTable[arr[i]] = 1
        if (arr[i] < min) min = arr[i]
        if (arr[i] > max) max = arr[i]
    }
    for (let i = min; i <= max; i++) {
        if (i in hashTable) {
            for (let j = 0; j < hashTable[i]; j++) {
                rs.push(i)
            }
        }
    }
    return rs
}

冒泡排序

实现思路：两层for循环，值与值后面的每一个值进行比较，交换

let bubbleSort = arr => {
    for (let i = 0; i < arr.length - 1; i++) {
        for (let j = i + 1; j < arr.length; j++) {
            if (arr[i] > arr[j]) {
                let temp = arr[i]
                arr[i] = arr[j]
                arr[j] = temp
            }
        }
    }
    return arr
}

插入排序

实现思路：循环数组，从后向前对比，找到相应位置插入

let insertSort = arr => {
    let len = arr.length
    let preIndex, current
    for (let i = 1; i < len; i++) {
        preIndex = i - 1
        current = arr[i]
        while (preIndex >= 0 && current < arr[preIndex]) {
            arr[preIndex + 1] = arr[preIndex]
            preIndex--
        }
        arr[preIndex + 1] = current
    }
    return arr
}