基于动态数组建立二叉堆、批量建堆-JAVA

1、堆的数据结构

• 如果任意节点的值总是≥子节点的值，称为：最大堆、大根堆、大顶堆
• 如果任意节点的值总是≤子节点的值，称为：最小堆、小根堆、小顶堆

一般使用数组实现二叉堆

图中序号为数组下标
用数组实现它索引的规律：（n为元素数量，i为数组索引）

• 如果i=0,它是根节点
• 如果i>0，它父节点的编号为floor((i-1)/2)
• 如果2i+1≤n-1，它的左子节点编号为2i+1
• 如果2i+1>n-1，它无左子节点
• 如果2i+2≤n-1，它的右子节点编号为2i+2
• 如果2i+2>n-1，它无右子节点

那么如何建立一个二叉堆呢？

以数组的形式 主要就是在添加的时候就进行上滤操作去排号数组顺序那么接下来着重说一下添加八

2、添加

添加的时候比如上图我们再添加一个元素肯定是要添加在序号为3的左下方，比如我们添加一个80。添加完如下图

80 刚开始是在3的位置，那么我们就要上虑去和它的根节点去比较的，指导它小于根节点或者它的下标为0

3、删除

删除思想，这里删除指的是删除堆顶，即80，通常删除操作时把最后的一个元素即3覆盖到80的位置，然后逐个向下比较去做一个下虑操作
把左右叶子中最大的那个数交换上来

知道思路后我们看代码

4、代码实现

1.首先定义接口

• 定义出常用操作

public interface Heap<E> {
    /**
     * 元素数量
     *
     * @return
     */
    int size();

    /**
     * 是否为空
     *
     * @return
     */
    boolean isEmpty();

    /**
     * 清空堆元素
     */
    void clear();

    /**
     * 添加元素
     *
     * @param element
     */

    void add(E element);

    /**
     * 获得堆顶元素
     *
     * @return
     */
    E get();

    /**
     * 删除堆顶元素
     *
     * @return
     */
    E remove();

    /**
     * 删除堆顶元素的同时插入一个元素
     *
     * @param element
     * @return
     */
    E replace(E element);

}

2.写实现类

import java.util.Comparator;

/**
 * @Description: 二叉堆
 * @ClassName algorithm
 * @Author: 王瑞文
 * @Date: 2021/3/26 13:06
 */
@SuppressWarnings("all")
public class BinaryHeap<E> implements Heap<E> {
    private E[] elements;
    private int size;
    private Comparator<E> comparator;

    //默认容量
    private static final int DEFAULT_CAPACITY = 10;

    //构造方法
    public BinaryHeap(Comparator<E> comparator) {
        this.comparator = comparator;
        this.elements = (E[]) new Object[DEFAULT_CAPACITY];
    }

    public BinaryHeap() {
        this.elements = (E[]) new Object[DEFAULT_CAPACITY];
    }

    public BinaryHeap(E[] elements) {
        if (elements == null || elements.length == 0) {
            this.elements = (E[]) new Object[DEFAULT_CAPACITY];
        } else {
            size = elements.length;
            int capacity = Math.max(elements.length, DEFAULT_CAPACITY);
            this.elements = (E[]) new Object[capacity];
            for (int i = 0; i < elements.length; i++) {
                this.elements[i] = elements[i];
            }
            heapify();
        }

    }

    private void heapify() {
        //自上而下的上虑
//        for (int i = 1; i < size; i++) {
//            siftUp(i);
//        }
        //自下而上的下虑
        for (int i = (size >> 1) - 1; i >= 0; i--) {
            siftDown(i);
        }
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public void clear() {

        for (int i = 0; i < size; i++) {
            elements[i] = null;
        }
        size = 0;

    }

    @Override
    public void add(E element) {

        elementNullCheck(element);

        ensureCapacity(size + 1);

        elements[size++] = element;// 还需要检测是否满足最大/最小堆的特性

        siftUp(size - 1);//最后于一个元素上滤

    }

    @Override
    public E get() {
        emptyCheck();
        return elements[0];
    }

    @Override
    public E remove() {
        emptyCheck();
        // 用最后一个元素覆盖到顶点 然后下滤
        E topElements = elements[0];
        int lastIndex = --size;
        elements[0] = elements[lastIndex];
        elements[lastIndex] = null;
        //下虑
        siftDown(0);
        return topElements;

    }

    @Override
    public E replace(E element) {//把新添加的元素添加到堆顶，然后下虑
        E topElement = null;
        elementNullCheck(element);
        if (size == 0) {
            elements[0] = element;
            size = 1;
            topElement = element;
        } else {
            topElement = elements[0];
            elements[0] = element;
            siftDown(0);
        }
        return topElement;
    }

    //上滤
    private void siftUp(int node) {
        E element = elements[node];
        while (node > 0) {
            int parentIndex = (node - 1) >> 1;
            E parent = elements[parentIndex];
            //小于父节点位置合适，直接退出
            if (compare(parent, element) >= 0) break;
            //调换位置
            elements[node] = parent;
            node = parentIndex;
        }
        elements[node] = element;
    }

    //下虑
    private void siftDown(int index) {

        E element = elements[index];
        // 第一个叶子节点之后全部都是叶子节点  ==》第一个叶子节点的数量就是根的数量
        int rootNum = size >> 1;

        while (index < rootNum) {//需要保证index索引位置是根节点，叶子节点没办法进行下虑操作
            // 1、只有左节点 2、同时有左右
            int ChildIndex = index * 2 + 1;
            E child = elements[ChildIndex];
            //选左右最大的节点进行比较
            int rightChildIndex = ChildIndex + 1;
            if (rightChildIndex < size && compare(elements[rightChildIndex], child) >= 0) {
                child = elements[ChildIndex = rightChildIndex];
            }
            if (compare(element, child) >= 0) break;
            //下虑 将子节点存到index位置
            elements[index] = child;
            index = ChildIndex;
        }
        elements[index] = element;

    }

    //比较
    private int compare(E e1, E e2) {
        return comparator != null ? comparator.compare(e1, e2) : ((Comparable<E>) e1).compareTo(e2);
    }

    //空检查
    public void emptyCheck() {
        if (size == 0)
            throw new IndexOutOfBoundsException("Heap  is Empty!");
    }

    private void ensureCapacity(int capacity) {
        int oldCapacity = elements.length;
        if (oldCapacity >= capacity) return;

        int newCapacity = oldCapacity + (oldCapacity >> 1);
        E[] newElements = (E[]) new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newElements[i] = elements[i];
        }
        elements = newElements;
        System.out.println("扩容完成：" + oldCapacity + "-->" + newCapacity);
    }

    private void elementNullCheck(E element) {
        if (element == null)
            throw new NullPointerException("element not allow enpty!");
    }
}

以上代码有注释，代码在这里不做过多解释

5、如何批量建堆

• 自上而下的上虑（除了根节点都下虑） O(nlog(n))
  

• 自下而上的下虑 （一半节点下虑） --效率高 O(n)

   private void heapify() {
        //自上而下的上虑
//        for (int i = 1; i < size; i++) {
//            siftUp(i);
//        }
        //自下而上的下虑
        for (int i = (size >> 1) - 1; i >= 0; i--) {
            siftDown(i);
        }
    }