本文共 3007 字，大约阅读时间需要 10 分钟。

转载自  

什么是二叉堆？

二叉堆本质上是一种完全二叉树，它分为两个类型：

1.最大堆

2.最小堆

什么是最大堆呢？最大堆任何一个父节点的值，都大于等于它左右孩子节点的值。

什么是最小堆呢？最小堆任何一个父节点的值，都小于等于它左右孩子节点的值。

二叉堆的根节点叫做堆顶。

最大堆和最小堆的特点，决定了在最大堆的堆顶是整个堆中的最大元素；最小堆的堆顶是整个堆中的最小元素。

堆的自我调整

对于二叉堆，如下有几种操作：

插入节点

删除节点

构建二叉堆

这几种操作都是基于堆的自我调整。

下面让我们以最小堆为例，看一看二叉堆是如何进行自我调整的。

1.插入节点

二叉堆的节点插入，插入位置是完全二叉树的最后一个位置。比如我们插入一个新节点，值是 0。

这时候，我们让节点0的它的父节点5做比较，如果0小于5，则让新节点“上浮”，和父节点交换位置。

继续用节点0和父节点3做比较，如果0小于3，则让新节点继续“上浮”。

继续比较，最终让新节点0上浮到了堆顶位置。

2.删除节点

二叉堆的节点删除过程和插入过程正好相反，所删除的是处于堆顶的节点。比如我们删除最小堆的堆顶节点1。

这时候，为了维持完全二叉树的结构，我们把堆的最后一个节点10补到原本堆顶的位置。

接下来我们让移动到堆顶的节点10和它的左右孩子进行比较，如果左右孩子中最小的一个（显然是节点2）比节点10小，那么让节点10“下沉”。

继续让节点10和它的左右孩子做比较，左右孩子中最小的是节点7，由于10大于7，让节点10继续“下沉”。

这样一来，二叉堆重新得到了调整。

3.构建二叉堆

构建二叉堆，也就是把一个无序的完全二叉树调整为二叉堆，本质上就是让所有非叶子节点依次下沉。

我们举一个无序完全二叉树的例子：

首先，我们从最后一个非叶子节点开始，也就是从节点10开始。如果节点10大于它左右孩子中最小的一个，则节点10下沉。

接下来轮到节点3，如果节点3大于它左右孩子中最小的一个，则节点3下沉。

接下来轮到节点1，如果节点1大于它左右孩子中最小的一个，则节点1下沉。事实上节点1小于它的左右孩子，所以不用改变。

接下来轮到节点7，如果节点7大于它左右孩子中最小的一个，则节点7下沉。

节点7继续比较，继续下沉。

这样一来，一颗无序的完全二叉树就构建成了一个最小堆。

堆的代码实现

在撸代码之前，我们还需要明确一点：

二叉堆虽然是一颗完全二叉树，但它的存储方式并不是链式存储，而是顺序存储。换句话说，二叉堆的所有节点都存储在数组当中。

数组中，在没有左右指针的情况下，如何定位到一个父节点的左孩子和右孩子呢？

像图中那样，我们可以依靠数组下标来计算。

假设父节点的下标是parent，那么它的左孩子下标就是 2*parent+1；它的右孩子下标就是  2*parent+2 。

比如上面例子中，节点6包含9和10两个孩子，节点6在数组中的下标是3，节点9在数组中的下标是7，节点10在数组中的下标是8。

7 = 3*2+1

8 = 3*2+2

刚好符合规律。

有了这个前提，下面的代码就更好理解了：

public class HeapOperator {/*** 上浮调整* @param array     待调整的堆*/public static void upAdjust(int[] array) {   int childIndex = array.length-1;   int parentIndex = (childIndex-1)/2;   // temp保存插入的叶子节点值，用于最后的赋值   int temp = array[childIndex];   while (childIndex > 0 && temp < array[parentIndex])   {       //无需真正交换，单向赋值即可       array[childIndex] = array[parentIndex];       childIndex = parentIndex;       parentIndex = (parentIndex-1) / 2;   }   array[childIndex] = temp;}/*** 下沉调整* @param array     待调整的堆* @param parentIndex    要下沉的父节点* @param parentIndex    堆的有效大小*/public static void downAdjust(int[] array, int parentIndex, int length) {   // temp保存父节点值，用于最后的赋值   int temp = array[parentIndex];   int childIndex = 2 * parentIndex + 1;   while (childIndex < length) {       // 如果有右孩子，且右孩子小于左孩子的值，则定位到右孩子       if (childIndex + 1 < length && array[childIndex + 1] < array[childIndex]) {           childIndex++;       }       // 如果父节点小于任何一个孩子的值，直接跳出       if (temp <= array[childIndex])           break;       //无需真正交换，单向赋值即可       array[parentIndex] = array[childIndex];       parentIndex = childIndex;       childIndex = 2 * childIndex + 1;   }   array[parentIndex] = temp;}/*** 构建堆* @param array     待调整的堆*/public static void buildHeap(int[] array) {   // 从最后一个非叶子节点开始，依次下沉调整   for (int i = array.length / 2; i >= 0; i--) {       downAdjust(array, i, array.length - 1);   }}public static void main(String[] args) {   int[] array = new int[] {1,3,2,6,5,7,8,9,10,0};   upAdjust(array);   System.out.println(Arrays.toString(array));   array = new int[] {7,1,3,10,5,2,8,9,6};   buildHeap(array);   System.out.println(Arrays.toString(array));}}

代码中有一个优化的点，就是父节点和孩子节点做连续交换时，并不一定要真的交换，只需要先把交换一方的值存入temp变量，做单向覆盖，循环结束后，再把temp的值存入交换后的最终位置。

转载地址：https://maokun.blog.csdn.net/article/details/82919720 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！