堆的概念及基本实现

堆的概念

1.堆是一颗完全二叉树(结构上)
2.从节点值的要求
根节点一定不小于左右子树–最大堆
根节点一定不大于左右子树–最小堆
3.最大堆–根节点 >= 左右子树
最小堆–根节点 <= 左右子树
4.堆的表示(使用数组)
a.数组索引从1开始
元素编号和索引一一对应，浪费0这个位置


数组中索引从1开始存储堆节点，对于一个索引值为K的节点来说，k>0
parent(k) = k / 2
leftChild(k) = 2k
rightChild(k) = 2k + 1
b.数组中索引从0开始


数组中索引从0开始存储堆节点，对于一个索引值为K的节点来说，k>0
parent(k) = (k-1) / 2
leftChild(k) = 2k + 1
rightChild(k) = 2k + 2

堆的实现

(基本都是基于二叉树，二叉堆)

package heap;

import java.util.ArrayList;
import java.util.Arrays;

/**
 * 基于int的最大堆
 * 根节点从0开始编号
 */
public class MaxHeap{
    //具体存储元素的动态数组
    private ArrayList<Integer> data;
    //无参构造
    public MaxHeap(){
        data = new ArrayList<>();
    }
    //有参构造
    public MaxHeap(int capacity){
        data = new ArrayList<>(capacity);
    }
    public boolean isEmpty(){
        return data.size() == 0;
    }

    

    /**
     * 将value存储在堆中
     * @param value
     */
    public void add(int value){
        //在数组末尾添加元素
        this.data.add(value);
        //进行元素的上浮操作
        siftUp(data.size() - 1);
    }

    /**
     * 调整k位置所在的元素，使其仍然满足最大堆的性质
     * @param k
     */
    private void siftUp(int k) {
        //走到根节点 k==0
        //当前节点值 <= 根节点值
        while (k > 0 && data.get(k) > data.get(parent(k))){
            //交换当前位置元素和父节点的元素即可
            int parent = parent(k);
            swap(k,parent);
            k = parent;
        }
    }

    /**
     * 交换当前data数组中k和parent索引的元素
     * @param k
     * @param parent
     */
    private void swap(int k, int parent) {
        int tmp = data.get(k);
        data.set(k,data.get(parent));
        data.set(parent,tmp);
    }

    /**
     * 取出当前最大堆的最大值
     * @return
     */
    public int extractMax(){
        //判断堆是否为空
        if(data.size() == 0){
            System.err.println("heap is empty!");
        }
        int max = data.get(0);
        int lastElement = data.get(data.size() - 1);
        data.set(0,lastElement);
        data.remove(data.size() - 1);
        siftDown(0);
        return max;
    }

    /**
     * 将索引为i的元素进行下沉操作，使其仍然满足最大堆的性质
     * @param i
     */
    private void siftDown(int i) {
        //当还有子树时说明还没有判断结束
        //若左孩子都不存在，那一定不存在右孩子
        while(leftChild(i) < data.size()){
            //此时仍然存在右子树
            int j = leftChild(i);
            //此时还存在右子树且右子树的值大于左子树
            if(j + 1 < data.size() && data.get(j + 1) > data.get(j)){
                //j一定保存了左右子树的最大值索引
                j = j + 1;
            }
            if (data.get(i) > data.get(j)){
                //此时i对应的元素已经下沉到合适的位置
                break;
            }else{
                swap(i,j);
                i = j;
            }
        }
    }

    /**
     * 根据孩子节点索引k求父亲节点索引
     * @param k
     * @return
     */
    private int parent(int k){
        return (k - 1) / 2;
    }

    /**
     * 根据父亲节点下标求左孩子节点下标
     * @param k
     * @return
     */
    private int leftChild(int k){
        return 2 * k + 1;
    }

    /**
     * 根据父亲节点下标求右孩子节点下标
     * @param k
     * @return
     */
    private int rightChild(int k){
        return 2 * k + 2;
    }

    @Override
    public String toString() {
        return data.toString();
    }

    public static void main(String[] args) {
        int[] data = {17,90,68,12,15,14,70,30,20};
        MaxHeap heap = new MaxHeap(data.length);
        for (int i = 0; i < data.length; i++) {
            heap.add(data[i]);
        }
        for (int i = 0; i < data.length; i++) {
            data[i] = heap.extractMax();
        }
        System.out.println(Arrays.toString(data));
    }
}