有时候也挺迷惑的，技术那么多，感觉学什么都来不及，又什么都得学，经常一看别人，哇，比你年轻比你厉害，然后自己emo一下又要鸡血模式，就挺无语的，但愿我们的坚持与努力都不白费吧，虽然开发可能不是一辈子的事，但但是干一天优秀一天，也是很有价值感的，加油共勉
二叉堆(Binary Heap)是一种特殊的完全二叉树数据结构，用于高效地实现优先队列。二叉堆可以分为两种类型：最小堆(Min Heap)和最大堆(Max Heap)。
在最小堆中，每个父节点的值都不大于其子节点的值；
而在最大堆中，每个父节点的值都不小于其子节点的值。
二叉堆的关键特性是它提供了对堆中元素的快速访问、插入和删除操作，所有这些操作的时间复杂度都是 O(log n)，其中 n 是堆中的元素数量。
完全二叉树与二叉堆的关系
完全二叉树是一种二叉树，除了最后一层外，每一层都是满的，并且最后一层的所有节点都尽可能地向左靠拢。二叉堆就是基于这种结构的，也就是说，二叉堆满足完全二叉树的定义，同时还要满足堆的性质。
物理存储与逻辑结构
虽然二叉堆在逻辑上表现为一棵树，但在计算机内存中通常使用数组来存储。数组的索引被用来表示树中的节点位置。具体来说有如下特性：
-
数组的第 0 个位置通常不使用，从第 1 个位置开始存储第一个元素（即根节点）。
-
对于任意节点 i：
-
其左子节点的位置是 2i。
-
其右子节点的位置是 2i + 1。
-
其父节点的位置是 i / 2（向下取整）。
-
任何索引大于或等于堆大小一半(size / 2)的节点都不可能有右孩子（因为这些节点处于树的最后一层或倒数第二层，都是叶子节点，它们最多只有一个孩子或没有孩子），这句话啥意思呢
可以看p001这个图，上图节点数是8/2=4，大于等于4的有5,6,7，8，都是叶子节点，这四个8在最底层，5,6,7在倒数第二层
这种存储方式使得二叉堆的操作非常高效，因为可以通过简单的数学运算来计算出父节点和子节点的数组位置。
基本操作
插入元素
当插入新元素时，首先将元素添加到数组的末尾，然后执行上浮操作(Bubble Up)，即比较该元素与其父节点，如果违反了堆的性质，则交换它们的位置，继续向上比较直到找到合适的位置。
删除元素
删除元素通常是删除堆顶元素（最小堆中最小的元素，最大堆中最大的元素）。首先，将堆顶元素与最后一个元素交换，然后删除原数组末尾的元素，最后执行下沉操作(Sink Down)，即比较当前堆顶元素与其子节点，如果违反了堆的性质，则与较小（最小堆）或较大（最大堆）的子节点交换位置，继续向下比较直到找到合适的位置（后面会用代码讲解，别着急）。
应用场景
二叉堆常用于实现优先队列(PriorityQueue的原理就是二叉堆)，如在任务调度、事件驱动的模拟程序、Dijkstra 算法（最短路径算法）、Huffman 编码（数据压缩）等领域。
示例代码
下面是一个简单的最小堆实现示例，使用数组存储，注释都已经写清楚了，大家可以揣摩下
import java.util.Arrays;
/**
* 二叉堆
* 最小堆在上，最大在下
*/
public class MinHeap {
//容量
private int capacity = 10;
//当前堆中元素个数
private int size = 0;
//堆数据
private int[] data;
public MinHeap(int capacity) {
data = new int[capacity];
this.capacity = capacity;
}
public static void main(String[] args) {
MinHeap heap = new MinHeap(10);
heap.put(4);
heap.put(9);
heap.put(3);
heap.put(7);
heap.put(2);
heap.put(12);
heap.put(6);
heap.put(1);
heap.put(5);
heap.put(8);
heap.print();
heap.remove();
heap.print();
}
/**
* 插入节点
*
* @param value 键值
* @return 成功或失败
*/
public boolean put(int value) {
//数组已满
if (size > capacity) {
System.out.println("数组已满");
return false;
}
//直接将新节点插入到数据尾部
data[size] = value;
//插入节点后不满足二叉堆特性，需要重新堆化 先传后加
shiftUp(size++);
return true;
}
private void print(){
System.out.println(Arrays.toString(data));
System.out.println(data[0]);
}
/**
* 自下而上堆化
* @param pos 堆化的位置
*/
private void shiftUp(int pos) {
// parent 堆化位置的父节点；计算公式：父节点=子节点*2
// 向上堆化过程
System.out.println("开始堆化" + pos);
if (pos == 0) {
return;
}
while (true){
int parent = (pos - 1) >>> 1;
System.out.println("父-" + data[parent] + " 子-" + data[pos]);
if (data[parent] > data[pos]){
System.out.println("交换" + parent + "和" + pos);
swap(parent, pos);
System.out.println("交换后-父-" + data[parent] + " 子-" + data[pos]);
if (parent == 0) {
break;
}
pos = parent;
}else {
break;
}
}
}
/**
* 数组数据交换
*
* @param i 下标
* @param j 下标
*/
private void swap(int i, int j) {
int tmp = data[i];
data[i] = data[j];
data[j] = tmp;
}
/**
* 删除最小值 并返回该值
* @return
*/
public int remove() {
if (size < 1) {
return -1;
}
int min = data[0];
//将最后一个元素放到顶部 这个策略有可能需要堆化多次
data[0] = data[--size];
data[size] = 0;
//重新堆化
shiftDown(0);
return min;
}
/**
* 自上而下重新调整二叉堆
*
* @param pos 开始调整位置
*/
private void shiftDown(int pos) {
while (true) {
//左子树
int child = pos << 1 + 1;
if (child >= size) {
//没有子节点了
break;
}
// 如果有右子树，并且右子树小于左子树，则转而考虑右子树 谁更小考虑谁，减少循环次数
if (child + 1 < size && data[child + 1] < data[child]) {
child++;
}
// 如果父节点小于任何一个子节点，则已经满足最小堆性质，退出循环
if (data[pos] <= data[child]) {
break;
}
// 否则交换父节点与较小的子节点
swap(pos, child);
pos = child;
}
}
}
这个类展示了如何使用数组实现二叉堆的基本插入和上浮操作，实际应用中还需要实现其他操作如删除、调整等。
二叉堆堆化后输出为
[1, 2, 4, 3, 7, 12, 6, 9, 5, 8]
二叉堆就到这了，有啥问题评论留言
