二叉堆
- 二叉堆的根节点叫作
堆顶
- 二叉堆本质上是一种完全二叉树,它分为两个类型。
最大堆
。最大堆的任何一个父节点的值,都大于或等于它左、右孩子节点的值
最小堆
。最小堆的任何一个父节点的值,都小于或等于它左、右孩子节点的值
- 构建二叉堆,也就是把一个无序的完全二叉树调整为二叉堆,本质就是让所有非叶子节点依次“下沉”。从
最后一个非叶子节点
开始。
- 当二叉堆插入节点时,插入位置是
完全二叉树的最后一个位置
- 二叉堆删除节点的过程和插入节点的过程正好相反,所删除的是处于
堆顶
的节点。这时,为了继续维持完全二叉树的结构,我们把堆的最后一个节点
临时补到原本堆顶的位置,然后让这个节点做下沉操作
Java实现
public class BinaryHeap {
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));
}
public static void buildHeap(int[] array) {
for (int i = (array.length / 2) - 1; i >= 0; i--)
downAdjust(array, i, array.length);
}
public static void downAdjust(int[] array, int parentIndex, int length) {
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;
}
public static void upAdjust(int[] array) {
int childIndex = array.length - 1;
int parentIndex = (childIndex - 1) / 2;
int temp = array[childIndex];
while (childIndex > 0 && temp < array[parentIndex]) {
array[childIndex] = array[parentIndex];
childIndex = parentIndex;
parentIndex = (parentIndex - 1) / 2;
}
array[childIndex] = temp;
}
}
- 代码中有一个优化的点,就是在父节点和孩子节点做连续交换时,并不一定要真的交换,只需要先把交换一方的值存入temp变量,做单向覆盖,循环结束后,再把temp的值存入交换后的最终位置即可
复杂度分析
- 堆的插入和删除操作,时间复杂度是O(logn)
- 构建堆的时间复杂度并不是O(nlogn),而是O(n)。这涉及数学推导过程
二叉堆的应用
优先队列
- 优先队列不再遵循先入先出的原则,而是分为两种情况。
- 最大优先队列,无论入队顺序如何,都是当前最大的元素优先出队
- 最小优先队列,无论入队顺序如何,都是当前最小的元素优先出队
- 可以用最小堆来实现最小优先队列,这样的话,每一次入队操作就是堆的插入操作,每一次出队操作就是删除堆顶节点。
算法分析
- 二叉堆节点“上浮”和“下沉”的时间复杂度都是O(logn),所以优先队列入队和出队的时间复杂度也是O(logn)
Java实现
public class PriorityQueueImplByHeap {
private int[] array;
private int size;
public PriorityQueueImplByHeap(){
array = new int[32];
size = 0;
}
public void enQueue(int key){
if(size >= array.length) {
resize();
}
array[size++] = key;
upAdjust();
}
public int deQueue() throws Exception {
if (size <= 0)
throw new Exception("the queue is empty!");
int head = array[0];
array[0] = array[--size];
downAdjust();
return head;
}
public void upAdjust() {
int childIndex = size - 1;
int parentIndex = (childIndex - 1) / 2;
int temp = array[childIndex];
while (childIndex > 0 && temp < array[parentIndex]) {
array[childIndex] = array[parentIndex];
childIndex = parentIndex;
parentIndex = (parentIndex - 1) / 2;
}
array[childIndex] = temp;
}
public void downAdjust() {
int parentIndex = 0;
int temp = array[parentIndex];
int childIndex = 1;
while (childIndex < size) {
if (childIndex + 1 < size && array[childIndex + 1] < array[childIndex])
childIndex++;
if (temp <= array[childIndex]) break;
array[parentIndex] = array[childIndex];
parentIndex = childIndex;
childIndex = 2 * childIndex + 1;
}
array[parentIndex] = temp;
}
public void resize(){
int newSize = this.size * 2;
this.array = Arrays.copyOf(this.array, newSize);
}
public static void main(String[] args) throws Exception {
PriorityQueueImplByHeap priorityQueueImplByHeap = new PriorityQueueImplByHeap();
priorityQueueImplByHeap.enQueue(3);
priorityQueueImplByHeap.enQueue(7);
priorityQueueImplByHeap.enQueue(1);
priorityQueueImplByHeap.enQueue(4);
System.out.println(priorityQueueImplByHeap.deQueue());
System.out.println(priorityQueueImplByHeap.deQueue());
System.out.println(priorityQueueImplByHeap.deQueue());
System.out.println(priorityQueueImplByHeap.deQueue());
}
}
相关文章