聊聊算法--堆的构建和调整
先提个问题，完全二叉树/满二叉树，区别？前者是指每一层都是紧凑靠左排列，最后一层可能未排满，后者是一种特殊的完全二叉树，
每层都是满的，即节点总数和深度满足N=(2^n) -1。堆Heap，一堆苹果，为了卖相好，越好看的越往上放，就是大顶堆；为了苹果堆
的稳定，质量越小越往上放，就是小顶堆；堆首先是完全二叉树，但只确保父节点和子节点大小逻辑，不关心左右子节点的大小关系，
通常是一个可以被看做一棵树的数组对象，是个很常见的结构，比如BST对象，都与堆有关系，今天就说下这个重要的数据结构和应用。
作者原创文章，谢绝一切转载，违者必究！
本文只发表在"公众号"和"博客园"，其他均属复制粘贴！如果觉得排版不清晰，请查看公众号文章。
准备：
Idea2019.03/Gradle6.0.1/Maven3.6.3/JDK11.0.4
难度： 新手--战士--老兵--大师
目标：
1.堆的构建和调整算法
1 优先级队列
为理解堆的原理，先看优先级队列，它是一种数据结构，插入或者删除元素的时候，元素会自动排序，(优先级不是狭义的数值大小，
但为了通俗理解，这里以字母序为例)，通常使用数组存储，我们可以按照下图进行转换，序号 0 不用：
优先级队列的实现(Java版)：
public class PriorityQueue<Key extends Character> { /** 存储元素的数组 */ private Key[] keys; private int N = 0; public PriorityQueue(int capacity){ // 下标0不用，多分配一个单位 keys = (Key[]) new Character[capacity + 1]; } public Key max(){ return keys[1]; } public void insert(Key e){ N ++; keys[N] = e; swim(N); } public Key delMax(){ Key max = keys[1]; swap(1,N); keys[N] = null; N --; // 让第一个元素下沉到合适的位置 sink(1); return max; } /** 上浮第k个元素*/ private void swim(int k){ // 比父节点小，即进行交换，直到根 while (k > 1 && less(parent(k),k)){ swap(k,parent(k)); k = parent(k); } } /** 下沉第 k 个元素*/ private void sink(int k){ while(k < N){ int small = left(k); if (right(k) < N && less(right(k),left(k))){ small = right(k); } if (less(k,small)){ swap(k,small); k = small; } } } private void swap(int i,int j){ Key temp = keys[i]; keys[i] = keys[j]; keys[j] = temp; } /** 元素i和j大小比较*/ private boolean less(int i,int j){ // 'a' - 'b' = -1 ; return keys[i].compareTo(keys[j]) > 0; } /** 元素i的父节点*/ private int parent(int i){ return i/2; } /** 元素i的左子节点*/ private int left(int i){ return i * 2; } /** 元素i的右子节点*/ private int right(int i){ return i * 2 + 1; } }
以上代码解析：
1 swim 上浮，对于元素k，是否需要上浮，仅需与其父节点比较，大于父节点则交换，迭代直到根节点；
2 sink 下沉，对于元素k，是否需要下沉，需先比较其左右子节点，找出左右子节点中较小者，较小者若比父节点大，则交换，迭代直到末尾元素；
3 insert 插入，先将元素放到数组末尾位置，再对其进行上浮操作，直到合适位置；
4 delMax 删除最大值，大根堆，故第一个元素最大，先将首末元素交换，再删除末尾元素，再对首元素下沉操作，直到合适位置；
总结：以上只是Java简化版，java.util.PriorityQueue 是JDK原版，客官可自行研究。但设计还是非常有技巧的，值得思考一番，假设 insert 插入
到首位，会导致数组大量元素移动。delMax 若直接删除首位最大值，则需要进一步判断左右子节点大小，并进行先子节点上浮再首元素下沉操作。
有了这个堆结构，就可以进行堆排序了，将待排数全部加入此堆结构，然后依次取出，即成有序序列了！
2 堆排序
如要求不使用上述堆数据结构。思路(升序为例)：将数组构建为一个大顶堆，首元素即为数组最大值，首尾元素交换；排除末尾元素后调整大顶堆，
则新的首元素即为次最大值，交换首尾并再排除末尾元素；如此循环，最后的数组即为升序排列。
public class HeapSort02 { public static void main(String []args){ int []arr = {2,1,8,6,4,7,3,0,9,5}; sort(arr); System.out.println(Arrays.toString(arr)); } public static void sort(int []arr){ int len = arr.length; // 创建一个大顶堆 for(int i = (int) Math.ceil(len/2 - 1); i >= 0; i--){ //从第一个非叶子结点从下至上，从右至左调整结构 adjustHeap(arr,i,len); } // 交换首尾元素，并重新调整大顶堆 for(int j = len-1;j > 0;j--){ swap(arr,0,j); adjustHeap(arr,0,j); } } /** 迭代写法*/ public static void adjustHeap(int []arr,int i,int length){ int temp = arr[i]; for (int k = 2*i + 1; k < length; k=k*2 + 1) { // 注意这里的k + 1 < length // 如果右子节点大于左子节点，则比较对象为右子节点 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; } /** 递归写法*/ private static void adjustHeap2(int[] arr, int i, int len){ int left = 2 * i + 1; int right = 2 * i + 2; int maxIndex = i; // 注意这里的 left < len if (left < len && arr[left] > arr[maxIndex]){ maxIndex = left; } if (right < len && arr[right] > arr[maxIndex]){ maxIndex = right; } if (maxIndex != i){ swap(arr,i,maxIndex); adjustHeap2(arr,maxIndex,len); } } /** 交换元素 */ public static void swap(int []arr,int a ,int b){ int temp=arr[a]; arr[a] = arr[b]; arr[b] = temp; } }
以上代码解析：
1完全二叉树结构中，如果根节点顺序号为 0，总节点数为 N，则最末节点的父节点即为最后一个非叶子节点，顺序号为 ceil(N/2 -1)，
2 adjustHeap2 为啥使用三个参数，不用中间的参数可以？使用三个参数，是为了进行递归调用，因为递归肯定是缩小计算规模，而这里的形参arr和len是固定不变的；
3 adjustHeap是非递归写法，不用中间的参数可以？调用一在“构建大顶堆”处，可写为函数体内初始化 i，并形成双重 for 循环；调用二在“重新调整大顶堆”处，
可见中间参数为 0，可直接去掉。故回答是可以！但需要调整写法，且影响该方法复用，这里直接写为三个形参的函数更为优雅而已。
4非递归写法理解：类似插入排序思想(依次移动并找到合适的位置再插入)，先将 arr[i] 取出，然后此节点和左右子树进行比较，如子树更大则子节点上升一层，使
用for循环迭代到最终位置，并进行赋值；
以 i=0 为例：
5递归方式理解：定位目标元素的左右子树，若子树值更大，则进行值交换，且因为子树发生了变化，故需要对子树进行递归处理；
3 前K个最大的数
在N个数中找出前K个最大的数： 思路：从N个数中取出前K个数，形成一个数组[K]，将该数组调整为一个小顶堆，则可知堆顶为K个数中最小值，
然后依次将剩余 N-K 个数与堆顶比较，若大于，则替换掉并调整堆，直到所有元素加入完毕，堆中元素即为目标集合。
public class HeapSort { public static void main(String[] args) { int[] arr = new int[100]; for (int i = 0; i < 100; i++) { arr[i] = i + 1; } // 前10个最大的数 int k = 10; // 构造小顶堆 for (int i = (int) Math.ceil(k/2 - 1); i >= 0; i--) { adjustHeap(arr,i,k); } // 依次比较剩余元素 for (int i = 10; i < arr.length; i++) { if (arr[i] > arr[0]){ swap(arr,0,i); adjustHeap(arr,0,k); } } // 输出结果 for (int i = 0; i < 10; i++) { System.out.print(arr[i]+"-"); } } /** 非迭代写法 ,对arr[i]进行调整 */ private static void adjustHeap(int[] arr,int i,int length){ int temp = arr[i]; for (int k = i * 2 + 1; k < length; k = k * 2 + 1) { // 因第一次循环中可能越界，故需要 k+1 < length 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; } /** 递归写法 */ private static void adjustHeap2(int[] arr,int i,int length){ int left = i * 2 + 1; int right = i * 2 + 2; int samller = i; if (left < length && arr[left] > arr[samller]){ samller = right; } if (right < length && arr[right] > arr[samller]){ samller = right; } if (samller != i){ swap(arr,i,samller); adjustHeap2(arr,samller,length); } } /** 交换元素 */ public static void swap(int []arr,int a ,int b){ int temp=arr[a]; arr[a] = arr[b]; arr[b] = temp; } }
以上代码解析：按照"初始化—构建小顶堆—比较调整—输出结果"执行。注意for循环中，因第一次循环中未使用for语句条件判断，可能越界，故需要 k+1 < length。
输出结果如下：
请看官思考，如果需求变为找出N个数中找出前K个最小的数,该如何实现? 建议动脑且动手的写一遍！因为魔鬼在细节！
全文完！
我近期其他文章：
- 1 Dubbo学习系列之十九（Apollo配置中心）
- 2 聊聊算法——二分查找算法深度分析
- 3 DevOps系列——Jenkins/Gitlab自动打包部署
- 4 DevOps系列——Jenkins私服
- 5 DevOps系列——Gitlab私服
只写原创，敬请关注
