数据结构之堆

堆

堆(Heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵完全二叉树的数组对象.

堆总是满足下列性质：
堆中某个节点的值总是不大于或不小于其父节点的值；
堆总是一棵完全二叉树。

将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆

上图就是一个小堆.

堆和普通树的区别

堆并不能取代二叉搜索树，它们之间有相似之处也有一些不同。我们来看一下两者的主要差别：

节点的顺序:在二叉搜索树中，左子节点必须比父节点小，右子节点必须必比父节点大。但是在堆中并非如此。在最大堆中两个子节点都必须比父节点小，而在最小堆中，它们都必须比父节点大。

内存占用:普通树占用的内存空间比它们存储的数据要多。你必须为节点对象以及左/右子节点指针分配额为是我内存。堆仅仅使用一个数据来村塾数组，且不使用指针。

平衡:二叉搜索树必须是“平衡”的情况下，其大部分操作的复杂度才能达到O(log n)。你可以按任意顺序位置插入/删除数据，或者使用 AVL 树或者红黑树，但是在堆中实际上不需要整棵树都是有序的。我们只需要满足对属性即可，所以在堆中平衡不是问题。因为堆中数据的组织方式可以保证O(log n) 的性能。

搜索:在二叉树中搜索会很快，但是在堆中搜索会很慢。在堆中搜索不是第一优先级，因为使用堆的目的是将最大（或者最小）的节点放在最前面，从而快速的进行相关插入、删除操作.

大堆的建立:

public static void heapify(int[] array, int size, int index) {
    while (true) {
        int left = 2 * index + 1;
        if (left >= size) { return; }
        int max = left;
        if (left + 1 < size) {
            if (array[left + 1] > array[left]) {
                max = left + 1;
            }
        }
        if (array[index] >= array[max]) { return; }
        swap(array, index, max);
        index = max;
    }
}

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

// 准确的结果是 O(n)
// 粗略估算是 O(n * log(n))
public static void createHeap(int[] array, int size) {
    for (int i = (size - 2) / 2; i >= 0; i--) {
        heapify(array, size, i);
    }
}

小堆的建立:

public static void createHeapMin(int[] array, int size) {
    for (int i = (size - 2) / 2; i >= 0; i--) {
        heapifyMin(array, size, i);
    }
}
private static void swap(int[] array, int i, int j) {
    int t = array[i];
    array[i] = array[j];
    array[j] = t;
}
public static void heapifyMin(int[] array, int size, int index) {
    while (true) {
        int left = 2 * index + 1;
        if (left >= size) { return; }
        int min = left;
        if (left + 1 < size) {
            if (array[left + 1] < array[left]) {
                min = left + 1;
            }
        }
        if (array[index] <= array[min]) { return; }
        swap(array, index, min);
        index = min;
    }
}

堆的元素上调(大堆演示):
插入元素的时候用,将新元素插入到数组最后,使用上调即可

public static void adjustUp(int[] array, int index) {
    while (index > 0) {
        int parent = (index - 1) / 2;
        if (array[parent] >= array[index]) {
            return;
        }

        swap(array, index, parent);
        index = parent;
    }
}

堆的元素下调(大堆元素演示):

在删除一个元素用 . 将最后的一个元素赋给要删除元素的下标,然后进行下调操作,左后size–,将最后的元素删除

public class Heaps {
    public static void adjustDown(int[] array,int index){
        int max= array.length-1;
        array[index]=array[array.length-1];
        if(index*2+1>max){//没有左右孩子
            return;
        }else if(index*2+1==max){//有左孩子
            swap(array,index,index*2+1);
        }else{//两个孩子都有
            if(array[index*2+1]>=array[index*2+2]&&
                    array[index]<array[index*2+1]){
                swap(array,index,index*2+1);
            }else if(array[index]<array[index*2+2]){
                swap(array,index,index*2+2);
            }
        }
    }