堆

堆：实现了优先级队列的一种数据结构。由它实现的优先级队列的插入和删除的时间复杂度都是 O(logN)，尽管这样删除的时间变慢一些，但插入的时间快很多。当速度非常重要，且有很多插入操作时，可以选择堆来实现优先级队列。

堆的特点：

1）完全的二叉树，除了树的最后一层不需要满的，其它的每一层从左到右都是满的。

2）它常常用数组实现。

3）堆的条件：每一个节点的关键字都必须大于等于这个节点的子节点的关键字。

堆的二叉树中，根的坐标是0，从第二层开始，从左到右分别是1、2，第三层从左到右分别是3、4、5、6，第四层依次如此。。。
堆中没有数组没有空值，从下标 0 到 N-1 ，每个数据单元都有数据项。
假设最大的数据项是在根中，那么基于这堆的优先级队列是降序排列的。

由于堆是弱序的，所以难以遍历，也不能很方便得找到指定的关键字，因为在查找的过程中，没有足够的信息来决定选择通过节点的两个子节点中的哪一个走向下一层。至少它不能以O(logN)的时间内删除一个指定的关键字。

这些操作可以通过按顺序查找数组的每一个单元来执行，只能用较慢的速度O(N)时间执行。

数组表示一棵树的特性：若数组中节点的索引为x，则

• 它的父节点的下标为(x-1)/2
• 它的左子节点的下标为2*x+1
• 它的右子节点的下标为2*x+2

public class Node {

    private int iData;

    public Node(int i) {
        this.iData = i;
    }

    public int getiData() {
        return iData;
    }

    public void setiData(int iData) {
        this.iData = iData;
    }

}

public class Heap {

    private Node[] heapArray;

    private int maxSize;

    private int currentIndex;

    public Heap(int ms) {
        this.maxSize = ms;
        heapArray = new Node[maxSize];
        currentIndex = 0;
    }

    public boolean isEmpty() {
        return currentIndex == 0;
    }

    public boolean insert(int key) {
        if (currentIndex == maxSize - 1) {
            return false;
        }
        Node node = new Node(key);
        heapArray[currentIndex] = node;
        trickleUp(currentIndex++);
        return true;
    }

    public void trickleUp(int index) {
        int parent = (index - 1) / 2;
        Node bottom = heapArray[index];
        while (index > 0 && heapArray[parent].getiData() < bottom.getiData()) {
            heapArray[index] = heapArray[parent];
            index = parent;
            parent = (index - 1) / 2;
        }
        heapArray[index] = bottom;
    }

    public Node remove() {
        Node root = heapArray[0];
        heapArray[0] = heapArray[--currentIndex];
        trickleDown(0);
        return root;
    }

    public void trickleDown(int index) {
        int largerChild;
        Node top = heapArray[index];
        while (index < currentIndex / 2) { // while node has at least on child.
            int leftChild = 2 * index + 1;
            int rightChild = leftChild + 1;
            if (rightChild < currentIndex
                    && (heapArray[leftChild].getiData() < heapArray[rightChild]
                            .getiData())) {
                largerChild = rightChild;
            } else {
                largerChild = leftChild;
            }
            if (top.getiData() >= heapArray[largerChild].getiData()) {
                break;
            }
            heapArray[index] = heapArray[largerChild];
            index = largerChild;
        }
        heapArray[index] = top;

    }

    public boolean change(int index, int newValue) {
        if (index < 0 || index > currentIndex) {
            return false;
        }
        int oldValue = heapArray[index].getiData();
        heapArray[index].setiData(newValue);
        if (oldValue < newValue) {
            trickleUp(index);
        } else if (oldValue > newValue) {
            trickleDown(index);
        }
        return true;

    }

    public void diplay() {
        int begin = 0;
        int end = 0;
        while (true) {
            for (int i = begin; i <= end; i++) {
                if (i > currentIndex - 1) {
                    return;
                }
                System.out.print(heapArray[i].getiData() + "  ");
            }
            int c = end;
            end = end + (end - begin + 1) * 2;
            begin = c + 1;
            System.out.println();
        }
    }

}

    public static void main(String[] args) {
        Heap heap = new Heap(20);
        heap.insert(80);
        heap.insert(10);
        heap.insert(70);
        heap.insert(50);
        heap.insert(1000);
        heap.insert(30);
        heap.insert(40);
        heap.insert(70);
        heap.insert(60);
        heap.insert(120);
        heap.insert(150);
        heap.insert(140);
        heap.diplay();
    }

打印结果：
1000
150 140
70 120 70 40
10 60 50 80 30