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

选择排序

直接选择排序，每趟在n-i个记录中选取最小的作为序列的第i个元素，时间复杂度为：n2n^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;
}
}
}

堆排序，构造大（小）根堆来进行排序，时间复杂度为为：nlog2nn\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;
}
}
}