人的想法和感受是会随着时间的认知改变而改变，
原来你笃定不会变的事，也会在最后一刻变得释然
------ 24.10.10
堆
堆是基于二叉树实现的数据结构
大顶堆每个分支的上一个节点的权值要大于它的孩子节点
小顶堆每个分支的上一个节点的权值要小于它的孩子节点
大顶堆
威廉姆斯建堆算法
不断的向堆中添加节点，添加时与堆最末尾元素进行比较，如果权值大于最末尾元素，则不断上调与其（最末尾元素，不断更新）父元素比较，直到找到小于堆中某元素的值或更新到堆顶元素
时间复杂度为O(n*logn)
Floyd建堆算法
1.找到最后一个非叶子节点的索引【size / 2 - 1】
2.从后向前，对每个结点执行下潜（与其左右孩子节点中的较大值进行交换）
Floyd建堆算法复杂度
复杂度与堆的高度h有关，高度从下往上依次相加，交换次数为h-1，总交换次数为每个节点的总高度除以结点所在每一层的高度 *（高度-1）之和
推导出
O(n) = 2^h-h-1
∵ 2^h ≈ n，h ≈ log2n
因此Floyd建堆算法的时间复杂度为O(n)
大顶堆代码实现
java
import java.util.Arrays;
public class MaxHeap {
// 整数数组表示堆
int[] array;
int size;
public MaxHeap(int capacity) {
this.array = new int[capacity];
}
public MaxHeap(int[] array) {
this.array = array;
this.size = array.length;
heapify();
}
// 建堆
private void heapify(){
// 索引0为起点，如何找到最后的非叶子节点 size / 2 - 1
for (int i = size / 2 - 1; i >= 0; i--) {
down(i);
}
}
// 将parent索引处的元素下潜，与两个孩子中较大值进行交换，直至没有孩子或者没有孩子比它大
private void down(int parent) {
int left = 2*parent+1;
int right = left+1;
int max = parent;
if(left < size && array[left] > array[max]){
max = left;
}
if(right < size && array[right] > array[max]){
max = right;
}
if(max != parent){ // 找到了一个更大的孩子
swap(max,parent);
down(max);
}
}
// 交换两个索引处的元素
private void swap(int i, int j){
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
// 获取堆顶元素
// Returns：堆顶元素
public int peek(){
if(size == 0){
return -1;
}
return array[0];
}
// 删除堆顶元素
// Returns：堆顶元素
public int poll(){
if(size == 0){
return -1;
}
int top = array[0];
swap(0,size-1);
size--;
down(0);
return top;
}
/* 删除指定索引处的元素
Params：index - 索引
Returns：被删除元素
*/
public int poll(int index){
if(size == 0){
return -1;
}
int delete = array[index];
swap(index,size-1);
size--;
down(index);
return delete;
}
/* 替换堆顶元素
Params：replaced - 新元素
*/
public void replace(int replaced){
array[0] = replaced;
down(0);
}
/* 堆的尾部添加元素
Params:offered - 新元素
Returns：是否添加成功
*/
public boolean offer(int offered){
if(size == array.length){
return false;
}
up(offered);
size++;
return true;
}
/*
将offered元素上浮：直至offered小于父元素或者上浮到堆顶
Returns:新加入的元素
*/
private void up(int offered) {
int child = size;
while (child > 0){
int parent = (child-1) / 2;
if(array[child] > array[parent]){
array[child] = array[parent];
}else {
break;
}
child = parent;
}
array[child] = offered;
}
public static void main(String[] args) {
int[] array = {1,2,3,4,5,6,7};
MaxHeap maxHeap = new MaxHeap(array);
System.out.println(Arrays.toString(maxHeap.array));
maxHeap.replace(5);
System.out.println(Arrays.toString(maxHeap.array));
maxHeap.poll(2);
System.out.println(Arrays.toString(maxHeap.array));
System.out.println(maxHeap.peek());
maxHeap.poll();
System.out.println(Arrays.toString(maxHeap.array));
System.out.println(maxHeap.offer(5));
System.out.println(Arrays.toString(maxHeap.array));
maxHeap.poll();
System.out.println(Arrays.toString(maxHeap.array));
maxHeap.peek();
maxHeap.offer(9);
System.out.println(Arrays.toString(maxHeap.array));
}
}