js排序方法

function swap(ary, x, y) {
    if (x === y) return
    let temp = ary[x]
    ary[x] = ary[y]
    ary[y] = temp

}

//生成随机数：
function random(n) {
    let ary = new Array(n)
    return ary.fill().map(_ => Math.random() * n | )

}

//选择排序（ 不稳定）：
function selectSort(ary) {
    for (var i = ; i < ary.length - ; i++) {
        let min = i
        let change
        for (var j = i + ; j < ary.length; j++) {
            if (ary[j] < ary[min]) {
                min = j
            }
        }
        swap(ary, min, i)
        //     change = ary[min]
        //     ary[min] = ary[i]
        //     ary[i] = change
    }
    return ary
}

//冒泡排序：
function bubbleSort(ary, comparator) {
    let flag
    let l = ary.length
    for (let i = l - ; i >= ; i--) {
        flag = false
        for (let j = ; j < i; j++) {
            //if (ary[j + 1] < ary[j]) {
            if (comparator(ary[j], ary[j + ]) > ) {
                flag = true
                swap(ary, j, j + )
            }
        }
        if (!flag) {
            break
        }
    }
    return ary
}

function comparator(a, b) {
    if (a > b) {
        return
    } else {
        return -
    }
}

//归并排序 稳定的
function mergeSort(ary) {
    if (ary.length < ) {
        return ary.slice()
    }

    var mid = Math.floor(ary.length / )
    var left = mergeSort(ary.slice(, mid))
    var right = mergeSort(ary.slice(mid))
    var result = []

    while (left.length && right.length) {
        if (left[] <= right[]) {
            result.push(left.shift())
        } else {
            result.push(right.shift())
        }
    }

    result.push(...left, ...right)

    return result
}

//快速排序：
function partition(ary, comparator, start = , end = ary.length - , ) {
    if (start >= end) {
        return
    }

    var pivotIndex = Math.floor(Math.random() * (end - start + ) + start)
    var pivot = ary[pivotIndex]

    swap(ary, pivotIndex, end)

    for (var i = start - , j = start; j < end; j++) {
        if (comparator(ary[j], pivot) < ) {
            i++
            swap(ary, i, j)
        }
    }

    swap(ary, i + , end)
    partition(ary, comparator, start, i)
    partition(ary, comparator, i + , end)
    return ary
}

function quickSort(ary, comparator = (a, b) => a - b) {
    return partition(ary, comparator)
}

//堆排序
// function reheap(ary, topIndex, endIndex = ary.length - 1) {
//     if (topIndex > endIndex) {
//         return
//     }

//     var largestIndex = topIndex
//     var leftIndex = topIndex * 2 + 1
//     var rightIndex = topIndex * 2 + 1

//     if (leftIndex <= endIndex && ary[leftIndex] > ary[largestIndex]) {
//         largestIndex = leftIndex
//     }

//     if (rightIndex <= endIndex && ary[rightIndex] > ary[largestIndex]) {
//         largestIndex = rightIndex
//     }

//     if (largestIndex !== topIndex) {
//         swap(ary, largestIndex, topIndex)
//         reheap(ary, largestIndex, endIndex)
//     }
// }

// function heapify(ary) {
//     for (var i = ary.length - 1; i >= 0; i--) {
//         reheap(ary, i)
//     }
//     return ary
// }

// function heapSort(ary) {
//     heapify(ary)
//     for (var i = ary.length - 1; i >= 1; i--) {
//         swap(ary, 0, i)
//         reheap(ary, 0, i - 1)
//     }
//     return ary
// }
function reheap(ary, topIndex, endIndex = ary.length - ) {
    if (topIndex > endIndex) {
        return
    }

    var largestIndex = topIndex
    var leftIndex = topIndex *  +
    var rightIndex = topIndex *  + 

    if (leftIndex <= endIndex && ary[leftIndex] > ary[largestIndex]) {
        largestIndex = leftIndex
    }
    if (rightIndex <= endIndex && ary[rightIndex] > ary[largestIndex]) {
        largestIndex = rightIndex
    }

    if (largestIndex != topIndex) {
        swap(ary, largestIndex, topIndex)
        reheap(ary, largestIndex, endIndex)
    }
}

//把一个数组调整成一个堆
function heapify(ary) {
    for (var i = ary.length - ; i >= ; i--) {
        reheap(ary, i)
    }
    return ary
}

// 堆排序
function heapSort(ary) {
    heapify(ary)
    for (var i = ary.length - ; i >= ; i--) {
        swap(ary, , i)
        reheap(ary, , i - )
    }
    return ary
}

class PriorityQueue {
    constructor(comparator = (a, b) => a - b) {
        this.heap = []
        this.comparator = comparator
    }

    _show() {
        return
        showTree(el, this.heap)
    }

    _swap(i, j) {
        if (i !== j) {
            var temp = this.heap[i]
            this.heap[i] = this.heap[j]
            this.heap[j] = temp
        }
        this._show()
        return this
    }

    _reverseReheap(pos) {
        var parentPos = (pos - ) /  |
        if (parentPos >=  && this.comparator(this.heap[pos], this.heap[parentPos]) < ) {
            this._swap(pos, parentPos)
            this._reverseReheap(parentPos)
        }
    }

    push(val) {
        this.heap.push(val)
        this._reverseReheap(this.heap.length - )
    }

    _reheap(topIndex, endIndex = this.heap.length - ) {
        if (topIndex > endIndex) {
            return
        }

        var ary = this.heap

        var largestIndex = topIndex
        var leftIndex = topIndex *  +
        var rightIndex = topIndex *  + 

        if (leftIndex <= endIndex && this.comparator(ary[leftIndex], ary[largestIndex]) < ) {
            largestIndex = leftIndex
        }
        if (rightIndex <= endIndex && this.comparator(ary[rightIndex], ary[largestIndex]) < ) {
            largestIndex = rightIndex
        }

        if (largestIndex != topIndex) {
            swap(ary, largestIndex, topIndex)
            this._reheap(largestIndex, endIndex)
        }

    }

    pop() {
        if (heap.length === ) {
            return this.heap.pop()
        }
        var result = this.heap[]
        this.heap[] = this.heap.pop()
        this._reheap()
        return result
    }
}

请给你自己加油！