排序—选择排序（js实现）

选择排序

直接选择排序，每趟在n-i个记录中选取最小的作为序列的第i个元素，时间复杂度为：$n^2$

function StraightSelectSort (arr) {
    var i, j, len = arr.length;
    for (i = 0; i < len - 1; i++) {
        var k = i;
        var current = arr[k];
        for (j = i + 1; j < len; j++) {
            if (arr[j] < current) {
                current = arr[j];
                k = j;
            }
        }
        if (k !== i) {
            arr[k] = arr[i];
            arr[i] = current;
        }
    }
}

堆排序，构造大（小）根堆来进行排序，时间复杂度为为：$n\log_2n$
堆：堆就是一个完全二叉树，比完全二叉树要求更为严格的是，堆要求其左右子树的值不大于（不小于）其根节点的值
大根堆：左右子树的值不大于其根节点的值，整颗树的根节点为数值最大的节点
小根堆：左右子树的值不小于其根节点的值，整颗树的根节点为数值最小的节点

function HeapSelectSort (arr) {
    var len = arr.length,
        i,          
        result = new Int32Array(len + 1); 
    for (i = 1; i < len + 1; i++) {
        result[i] = arr[i - 1];
    }
    for (i = (len / 2) | 0; i >= 1; i--) {
        Restore(result, i, len);
    }
    for (i = len; i > 1; i--) {
        var temp = result[i];
        result[i] = result[1];
        result[1] = temp;
        Restore(result, 1, i - 1);
    }
    for (i = 0; i < len; i++) {
        arr[i] = result[i + 1];
    } 
}
// 构建大根堆
function Restore (arr, j, count) {
    while (j <= count / 2) {
        // 找出左右孩子中最大的索引
        var m = (2 * j + 1 <= count && arr[2 * j + 1] > arr[2 * j]) ? 2 * j + 1 : 2 * j;
        if (arr[m] > arr[j]) {
            var temp = arr[m];
            arr[m] = arr[j];
            arr[j] = temp;
            j = m;
        } else {
            break;
        }
    }
}