[数据结构] 2.7 Heap 堆
* 注: 本文/本系列谢绝转载，如有转载，本人有权利追究相应责任。
1.堆是什么？
（如图所示是一个小堆）
1)堆是一颗完全二叉树，它的最后一层不是满的，其他每一层都是满的，最后一层从左到右也没有空隙。
简单的说? 完全二叉树也就是没有缝隙的二叉树。
2)堆常常通过数组实现，因为 父子节点直接的关系直接可以通过数组的索引换算
parent(i) = i/2
left child(i) = 2*i + 1
right child(i) = 2*i + 2
3)对于最大堆来说，每个节点的值都不大于其父节点的值，也就是根节点是最大的。
对于最小堆来说，每个节点的值都不小于其父节点的值，也就是根节点是最小的
4)堆进行插入和删除的时间复杂度均为 O(LogN)
2.堆的应用
堆可以解决的首先就是topK问题，假设要从N大小的实数数组中找到topK，那么需要K*logN的时间。
当N=10000时
当N=10000*10000时
也就是说N可以放的足够大，K可以适当大一些，经过本机实验，堆在单机单线程下只需要14s就可以处理一亿数据的Top1W操作。
3.堆的实现
堆的操作主要是两个 add、remove，有些地方也会存在buildHeap的操作，我们分别捋一下它们的思路。
一下基于一个最大堆。
1) add操作，添加元素
思路:
将添加的元素放在数组尾部，进行“上浮”操作。也就是比较父元素，如果大于父元素则上浮。
实际长度 ++
/** * 插入过程需要上浮比较 * @param node */ public void insert(Node node){ if(actualSize == MAX_N){ System.out.println("当前堆已满!"); return; } // 插入 // 插入节点 nodes[actualSize] = node; // 上浮过程 // 调整堆，从这个节点开始与其夫节点进行比较，如果大于父节点则交换上浮 for(int i = actualSize; i > 0 ;i = getParentIndex(i)){ Node current = nodes[i]; Node parent = nodes[getParentIndex(i)]; if(parent.data < current.data){ nodes[i] = parent; nodes[getParentIndex(i)] = current; } } actualSize ++; }
2) remove操作，删除元素
思路:
获得堆顶的值，然后用堆底节点替换堆顶节点。并针对此节点进行"下沉"操作，所谓下沉，就是如果比较当前元素与左右子节点的值，如果比它们小，则与最大者交换。
实际长度 --
/** * 删除过程需要下沉比较 * @param node */ public void remove(Node node){ if(actualSize == 0){ System.out.println("当前堆已空!"); return; } if(actualSize == 1){ actualSize --; return; } // 删除过程 // 使用最后一个节点替换掉顶点 Node tailNode = nodes[actualSize-1]; nodes[0] = tailNode; actualSize --; // 下沉比较 for(int i = 0; i < actualSize;){ Node current = nodes[i]; Node leftChild = null; if(getLeftChildIndex(i) < actualSize){ leftChild = nodes[getLeftChildIndex(i)]; } Node rightChild = null; if(getRightChildIndex(i) < actualSize){ rightChild = nodes[getRightChildIndex(i)]; } if(leftChild == null && rightChild == null){ return; } if(leftChild != null && leftChild.data > current.data){ if(rightChild != null && rightChild.data > leftChild.data){ // 右枝最大 nodes[i] = rightChild; nodes[getRightChildIndex(i)] = current; // i走右枝 i = getRightChildIndex(i); continue; }else{ // 左枝最大 nodes[i] = leftChild; nodes[getLeftChildIndex(i)] = current; // i走左枝 i = getLeftChildIndex(i); continue; } }else{ if(rightChild != null && rightChild.data > current.data){ // 右枝最大 nodes[i] = rightChild; nodes[getRightChildIndex(i)] = current; // i走右枝 i = getRightChildIndex(i); continue; }else if(rightChild != null && rightChild.data <= current.data){ // 当前点最大 //保持现状,直接结束循环 break; } } } }
3)buildHeap操作，给一个数组，进行建立堆操作
思路:
遍历数组的每一个节点，针对每个节点进行"上浮"操作.
Code：
package ds6.heap; import java.util.Arrays; public class Heap { static class Node{ long data; public Node(long data) { this.data = data; } @Override public String toString() { return "Node{" + "data=" + data + '}'; } } /** * TopN最大值堆 */ static class TopNMaxHeap{ int MAX_N = 10; // Top N ,指定堆的最大大小 Node[] nodes; int actualSize = 0; public TopNMaxHeap(int MAX_N) { this.MAX_N = MAX_N; nodes = new Node[MAX_N]; } public void foreachPrint(){ System.out.println(Arrays.toString(nodes)); } /** * 删除过程需要下沉比较 * @param node */ public void remove(Node node){ if(actualSize == 0){ System.out.println("当前堆已空!"); return; } if(actualSize == 1){ actualSize --; return; } // 删除过程 // 使用最后一个节点替换掉顶点 Node tailNode = nodes[actualSize-1]; nodes[0] = tailNode; actualSize --; // 下沉比较 for(int i = 0; i < actualSize;){ Node current = nodes[i]; Node leftChild = null; if(getLeftChildIndex(i) < actualSize){ leftChild = nodes[getLeftChildIndex(i)]; } Node rightChild = null; if(getRightChildIndex(i) < actualSize){ rightChild = nodes[getRightChildIndex(i)]; } if(leftChild == null && rightChild == null){ return; } if(leftChild != null && leftChild.data > current.data){ if(rightChild != null && rightChild.data > leftChild.data){ // 右枝最大 nodes[i] = rightChild; nodes[getRightChildIndex(i)] = current; // i走右枝 i = getRightChildIndex(i); continue; }else{ // 左枝最大 nodes[i] = leftChild; nodes[getLeftChildIndex(i)] = current; // i走左枝 i = getLeftChildIndex(i); continue; } }else{ if(rightChild != null && rightChild.data > current.data){ // 右枝最大 nodes[i] = rightChild; nodes[getRightChildIndex(i)] = current; // i走右枝 i = getRightChildIndex(i); continue; }else{ // 当前点最大 //保持现状,直接结束循环 break; } } } } /** * 插入过程需要上浮比较 * @param node */ public void insert(Node node){ if(actualSize == MAX_N){ System.out.println("当前堆已满!"); return; } // 插入 // 插入节点 nodes[actualSize] = node; // 上浮过程 // 调整堆，从这个节点开始与其夫节点进行比较，如果大于父节点则交换上浮 for(int i = actualSize; i > 0 ;i = getParentIndex(i)){ Node current = nodes[i]; Node parent = nodes[getParentIndex(i)]; if(parent.data < current.data){ nodes[i] = parent; nodes[getParentIndex(i)] = current; } } actualSize ++; } public int getParentIndex(int x){ return (x-1)/2; } public int getLeftChildIndex(int x){ return 2*x + 1; } public int getRightChildIndex(int x){ return 2*x + 2; } } public static void main(String[] args) { TopNMaxHeap topNMaxHeap = new TopNMaxHeap(10); topNMaxHeap.insert(new Node(27)); topNMaxHeap.insert(new Node(33)); topNMaxHeap.insert(new Node(30)); topNMaxHeap.insert(new Node(31)); Node nodeToRemove = new Node(40); topNMaxHeap.insert(nodeToRemove); topNMaxHeap.insert(new Node(20)); topNMaxHeap.foreachPrint(); topNMaxHeap.remove(nodeToRemove); topNMaxHeap.foreachPrint(); } }
result:
[Node{data=40}, Node{data=33}, Node{data=30}, Node{data=27}, Node{data=31}, Node{data=20}, null, null, null, null]
[Node{data=33}, Node{data=31}, Node{data=30}, Node{data=27}, Node{data=20}, Node{data=20}, null, null, null, null]
4.堆排序
因为堆的这个特性，通过不断poll出堆顶元素就可以对元素列表进行排序。
测试:
public static void test2(){ int[] toSort = new int[]{ 7,10,6,8,9,3,5,4 }; TopNMaxHeap heap = new TopNMaxHeap(toSort.length); for(int i = 0 ; i < toSort.length; i++ ){ heap.insert(new Node(toSort[i])); } int[] result = new int[toSort.length]; for(int i = 0; i < toSort.length; i++ ){ result[i]=(int)heap.nodes[0].data; heap.remove(heap.nodes[0]); } System.out.println(Arrays.toString(result)); }
result:
[10, 9, 8, 7, 6, 5, 4, 3]
