满足如下结构性和堆序性，即为二叉堆。
结构性质：堆是一棵被完全填满的二叉树，有可能的例外是在底层，底层上的元素从左到右填入。这样的树称为完全二叉树。
容易证明，一棵高为 h 的完全二叉树有 2h 到 2h+1-1 个节点。这意味着完全二叉树的高是⌊ log N ⌋，显然它是 O( log N )。
一个重要的观察发现，因为完全二叉树这么有规律，所以它可以用一个数组表示而不需要使用链。
对于数组中任一位置 i 上的元素，其左儿子在位置 2i 上，右儿子在左儿子后的单元（2i + 1）中，它的父亲则在位置 ⌊ i/2 ⌋上。
堆序性质：任意节点都小于它的所有后裔。
基本的堆操作
insert( 插入 )
为将一个元素 X 插入到堆中，我们在下一个可用位置创建一个空穴，否则该堆将不是完全数。如果 X 可以放在该空穴中而不破坏堆的序，那么插入完成。否则，我们把空穴的父节点上的元素移入该空穴中，这样，空穴就朝着根的方向上冒一步。继续改过程直到 X 能被放入空穴中为止。
这样一般的策略叫做上滤( percolate up )；新元素在堆中上滤直到找出正确的位置。
public void insert( T x ){if( currentSize == array.length - 1 ){enlargeArray( array.length*2 + 1 );}//上滤int hole = ++currentSize;for( ; hole>1 && x.compareTo( array[ hole/2 ])<0; hole/=2 ){array[ hole ] = array[ hole/2 ];}array[ hole ] = x;}如果欲插入的元素是新的最小元从而一直上滤到根处，那么这种插入的时间将长达 O( log N )；
平均看来，上滤终止得要早，业已证明，执行一次插入平均需要 2.607 次比较，因此平均 insert 操作上移元素 1.607层。
deleteMin（删除最小元）
当删除一个最小元时，要在根节点建立一个空穴。由于现在堆少了一个元素，因此堆中最后一个元素 X 必须移动到该堆的某个地方。如果 X 可以直接被放到空穴中，那么 deleteMin 完成。不过这一般不太可能，因此我们将空穴的两个儿子中比较小者移入空穴，这样就把空穴向下推了一层。重复该步骤直到 X 可以被放入空穴中。因此，我们的做法是将 X 置入沿着从根开始包含最小儿子的一条路径上的一个正确的位置。
这种一般的策略叫做下滤（percolate down）。
public T deleteMin(){if( isEmpty() )throw new UnderflowException();T minItem = array[1];array[1] = array[ currentSize-- ];percolateDown( 1 );return minItem;}private void percolateDown( int hole ){int child;T tmp = array[ hole ];for( ; hole*2 <= currentSize; hole=child ){child = hole*2;if( child != currentSize && array[child+1].compareTo( array[child] ) <0 ){child++;}if( array[child].compareTo( tmp ) < 0 ){array[hole] = array[child];}else{break;}}array[hole] = tmp;}这种操作最坏情形运行时间为 O( log N )。平均而言，被放到根处得元素几乎下滤到堆的底层（即它所来自的那层），因此平均运行时间为 O( log N )。
decreaseKey（降低关键字的值）
decreaseKey( p, △ ) 操作降低在位置 p 处得项的值，降值幅度为正量△。由于这可能破坏堆序性质，因此必须通过上滤对堆进行调整。
该操作对系统管理员是有用的：系统管理员能够使他们的程序以最高的优先级来运行。
increaseKey（增加关键字的值）
increaseKey( p, △ )操作增加在位置 p 处得项的值，增值的幅度为正的量△。这可以用下滤来完成。
许多调度程序自动地降低正在过多地消耗 CPU 时间的进程的优先级。
delete（删除）
delete( p ) 操作删除堆中位置 p 上的节点。该操作通过首先执行 decreaseKey( p, ∞ )然后再执行 deleteMin( ) 来完成。
当一个进程被用户中止（而不是正常终止）时，它必须从优先队列中除去。
上述三种操作均以对数最坏情形时间运行。
buildHeap（构建堆）
有时二叉堆是 由一些项的初始集合构造而得。这种构造方法以 N 项作为输入，并把它们放到一个堆中。显然，这可以使用 N 个相继的 insert 操作来完成。由于每个 insert 将花费O( 1 )平均时间，以及 O(log N) 的最坏时间，因此该算法的总的运行时间是 O(N) 平均时间而不是 O(N log N) 最坏时间。
一般的算法是将 N 项以任意顺序放入树中，保持结构特性。此时，如果 percolateDown( i ) 从节点 i 下滤，那么 buildHeap 程序则可以由构造方法用于创建一棵堆序的树。
图6-15中的第一棵树是无序树。从图6-15到图6-18中其余7棵树表示出 7 个 percolateDown 中每一个的执行结果。每条虚线对应两次比较：一次是找出较小的儿子节点，另一个是较小的儿子与该节点的比较。注意，在整个算法中只有 10 跳虚线，它们对应 20 次比较。
public BinaryHeap( T[] items ){currentSize = items.length;array = (T[]) new Comparable[ (currentSize + 2) * 11 / 10 ];int i=1;for( T item : items ){array[ i++ ] = item;}buildHeap();}private void buildHeap(){for( int i = currentSize/2; i>0; i-- )percolateDown( i );}定理：包含 2h+1-1 个节点、高为 h 的理想二叉树的节点的高度的和为 2h+1-1 - ( h+1 )。
也就是： 节点的个数（N） ≈ 节点高度的和
完整代码：
public class BinaryHeap<T extends Comparable<? super T>> {private static final int DEFAULT_CAPACITY = 10;/*** 堆中元素个数*/private int currentSize;private T[] array;public BinaryHeap() {super();currentSize = 0;array = (T[]) new Comparable[ DEFAULT_CAPACITY ];}public BinaryHeap( T[] items ){currentSize = items.length;array = (T[]) new Comparable[ (currentSize + 2) * 11 / 10 ];int i=1;for( T item : items ){array[ i++ ] = item;}buildHeap();}private void buildHeap(){for( int i = currentSize/2; i>0; i-- )percolateDown( i );}private void enlargeArray( int size ){Comparable[] newArray = new Comparable[size];for( int i=1 ; i<array.length ; i++ ){newArray[i] = array[i];}array = (T[]) newArray;}public void insert( T x ){if( currentSize == array.length - 1 ){enlargeArray( array.length*2 + 1 );}//上滤int hole = ++currentSize;for( ; hole>1 && x.compareTo( array[ hole/2 ])<0; hole/=2 ){array[ hole ] = array[ hole/2 ];}array[ hole ] = x;}public boolean isEmpty(){return currentSize == 0;}/*** 删除最小* @return** Date :2012-7-6* Author :GongQiang*/public T deleteMin(){if( isEmpty() )throw new UnderflowException();T minItem = array[1];array[1] = array[ currentSize-- ];percolateDown( 1 );return minItem;}/*** 下滤* @param hole** Date :2012-7-6* Author :GongQiang*/private void percolateDown( int hole ){int child;T tmp = array[ hole ];for( ; hole*2 <= currentSize; hole=child ){child = hole*2;if( child != currentSize && array[child+1].compareTo( array[child] ) <0 ){child++;}if( array[child].compareTo( tmp ) < 0 ){array[hole] = array[child];}else{break;}}array[hole] = tmp;}
}class UnderflowException extends RuntimeException{}
