数据结构和算法之路---堆和堆排序
堆
1.是一种完全二叉树，第N层至少有 2 ^（n-1）个结点
2.大顶堆：父节点 大于左右子结点；小顶堆：父节点小于左右子结点
3.用一维数组来表示
4.最后一个非叶结点的下标 = length / 2 -1
parent = floor( ( (i -1) / 2 ) i > 1
left = i * 2+1;
right = i * 2 + 2;
堆的用途
- 构建优先队列
- 快速找到一个集合的最大值或者最小值
- 堆排序
- 斐波那契数列，Huffman数
- 朋友面前装逼
堆的主要方法
1.shiftUp( i )：跟父结点比较，将第i个结点往上冒，将结点在数组中的更靠前，主要用于insert
2.shiftDown( i , n) : n代表当前参与构建堆的结点数量，跟左右子结点比较，与shiftUp操作相反，主要用于remove，又称为 堆化(heapify)
shiftUp 或者 shiftDown 是一个递归的过程，所以它的时间复杂度是 O(log n)，这两个是堆的基本方法，其他都是基于它们产生的
3.insert( value )：将value添加到堆尾，然后调用shiftUp调整堆
4.remove( )：移除堆顶结点，然后将堆尾结点放在堆顶，调用shiftDown调整堆
// shiftUp
/**
* 往上冒 (小顶堆)
* @param arr 堆数组
* @param i 往上冒的结点下标
*/
function shiftUp(arr, i) {
if (i <= 0 || !arr) {
return;
}
// 为交换腾出坑
let tmpValue = arr[i];
while (i === 1 || Math.floor((i - 1) / 2) >= 0) {
let parent = i === 1 ? 0 : Math.floor((i - 1) / 2);
if (arr[parent] > tmpValue) {
arr[i] = arr[parent];
i = parent;
} else {
break;
}
}
arr[i] = tmpValue;
}
堆排序
1.基本思想：
a.先将无序数组构建成大顶堆（小顶堆）— 从最后的一个非叶结点开始，从下往上循环调整每个小二叉树，使其形成局部最优解
b.将根结点与叶结点交换位置 — 为了下次调整堆得时候，将最大（最小）的结点排除
c.循环的重新构建一次堆 — 因为已经构成了局部最优解，这次从上往下调整，最多调整一个分支
2.选择排序，所以是不稳定的
3.O(nlogn) — 第一次构建堆，用一次for循环为O(n)，以后每次循环调整 最后再遍历一个分支，即O(logn)
4.注：堆排序的主要应用并不是全排（快速排序更方便）更适用最优N解得问题，或者动态的数据；
对于已经构建好的堆，主要有两个操作，插入和删除
插入：插入到堆尾，然后从下往上调整堆
删除：将堆顶移动到堆尾，然后从上往下调整堆
// 堆排序
function heapSort(arr) {
if (!arr || typeof arr !== "object" || arr.constructor !== Array) {
return;
}
// 最后一个非叶节点的下标
let i = Math.floor(arr.length / 2) - 1;
// 构建大堆序
for (; i >= 0; i--) {
adjustHeap(arr, i, arr.length);
}
// 调换堆顶和结点位置,再从上往下调整堆
for (let j = arr.length - 1; j > 0; j--) {
let temp = arr[0];
arr[0] = arr[j];
arr[j] = temp;
adjustHeap(arr, 0, j)
}
}
/**
* 调整堆结构
* 从左往右，从下到上
*/
function adjustHeap(arr, i, length) {
let temp = arr[i];
for (let k = 2 * i + 1; k < length; k = 2 * k + 1) {
if (k + 1 < length && arr[k] > arr[k + 1]) {
k++;
}
if (arr[k] < temp) {
arr[i] = arr[k];
i = k;
} else {
break;
}
}
arr[i] = temp;
}
let arr = [12, 34, 2, 34, 5, 1, 0, 2, 5, 8, 9, 6, 3, 2, 33, 3, 3, 3, 5, 6, 8];
heapSort(arr);
console.log(arr);
堆代码实现
用JS 手动实现了堆结构，以及主要方法
/**
* 堆结构（小顶堆为例）
*/
class Heap {
constructor(arr) {
this.arr = arr;
}
get size() {
if (!this.arr || typeof this.arr !== "object" || this.arr.constructor !== Array) {
return 0;
}
return this.arr.length;
}
/**
* 将i位置的元素往上冒
* @param i
*/
shiftUp(i) {
if (this.size < 0) {
return;
}
let tempValue = this.arr[i];
while (i === 1 || Math.floor((i - 1) / 2) >= 0) {
let parent = i === 1 ? 0 : Math.floor((i - 1) / 2);
if (this.arr[parent] > tempValue) {
this.arr[i] = parent;
i = parent;
} else {
break;
}
}
this.arr[i] = tempValue;
}
/**
* 往下沉 （堆化heapify）
* @param i
*/
shiftDown(i, size) {
let length = size || this.size;
if (i < 0) {
return;
}
let tempValue = this.arr[i];
let k = i * 2 + 1;
while (k < length) {
if (k + 1 < length && this.arr[k] > this.arr[k + 1]) {
k++;
}
if (this.arr[k] < tempValue) {
this.arr[i] = this.arr[k];
i = k;
k = 2 * k + 1;
} else {
break;
}
}
this.arr[i] = tempValue;
}
/**
* 插入新元素
* 放到堆尾，然后往上冒
* @param value
*/
insert(value) {
this.arr.push(value);
this.shiftUp(this.size - 1);
}
/**
* 删除堆顶元素
* 1.移除堆顶
* 2.将堆尾的结点移到堆顶
* 3.往下沉
*/
remove() {
if (this.size <= 0) {
return;
}
if (this.size === 1) {
return this.arr.splice(0, 1);
} else {
let firstValue = this.arr[0];
this.arr[0] = this.arr[this.size - 1];
this.arr.splice(this.size - 1, 1);
this.shiftDown(0);
return firstValue;
}
}
/**
* 堆排序
* 1.先构建堆
* 2.再循环remove堆顶
* @param heap
*/
sort() {
Heap.createHeap(this);
for (let j = this.size - 1; j > 0; j--) {
let temp = this.arr[0];
this.arr[0] = this.arr[j];
this.arr[j] = temp;
this.shiftDown(0, j);
}
}
/**
* 构建堆
*
* @param heap
*/
static createHeap(heap) {
let arr = heap.arr;
if (!arr || typeof arr !== "object" || arr.constructor !== Array) {
return false;
}
//从最后一个非叶结点开上往上堆化
let node = Math.floor(arr.length / 2) - 1;
while (node >= 0) {
heap.shiftDown(node);
node--;
}
return true;
}
}
let arr = [12, 34, 2, 34, 5, 1, 0, 2, 5, 8, 9, 6, 3, 2, 33, 3, 3, 3, 5, 6, 8];
let heap = new Heap(arr);
Heap.createHeap(heap);
// heap.sort();
console.log(heap.arr);
// heap.remove();
heap.insert(-1);
console.log(heap.arr);