堆结构——Java实现

堆结构

概述

堆分为大顶堆和小顶堆。
堆需要满足两个条件：
（一）满足完全二叉树的要求
（二）大(小)顶堆父结点大(小)于左右子结点。

Java代码实现

public class Heap {

    /**
     * 堆中数据
     */
    private int[] array;

    /**
     * 堆中可存放总元素
     */
    private int size;

    /**
     * 堆中当前存放元素
     */
    private int count;

    /**
     * 构造函数 初始化堆中可以存储容量
     * @param capacity
     */
    private Heap(int capacity) {
        if (capacity <= 0) {
            return;
        }
        array = new int[capacity];
        size = capacity;
        count = 0;
    }

    /**
     * 向堆中插入数据  保持堆结构
     * @param data
     */
    public void insert(int data) {
        if (count == size) {
            return;
        }
        array[count] = data;
        int min = count++;
        //和父节点进行比较  如果比父节点大进行交换
        while ((min - 1) / 2 >= 0 && array[(min - 1) / 2] < array[min]) {
            swap(array, min, (min - 1) / 2);
            min = (min - 1) / 2;
        }
    }

    /**
     * 移除堆顶元素
     */
    public void removeTop() {
        if (count == 0) {
            return;
        }
        //将堆顶元素和堆中最后一个元素交换
        swap(array, 0, count - 1);
        array[count - 1] = 0;
        //将堆中剩余的元素进行堆化
        heapify(array, 0, --count);
    }

    /**
     * 自上而下进行堆化
     * @param array 数组元素
     * @param i 头结点索引
     * @param n 堆中元素
     */
    private void heapify(int[] array, int i, int n) {

        while (true) {
            int max = i;
            //将父结点 和其子结点进行比较 如果小于  进行交换
            if (2 * i + 1 < n && array[2 * i + 1] > array[i]) {
                max = 2 * i + 1;
            }
            if (2 * i + 2 < n && array[2 * i + 2] > array[max]) {
                max = 2 * i + 2;
            }
            if (max == i) {
                break;
            }
            swap(array, i, max);
            i = max;
        }
    }

    private void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

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