最大堆的插入/删除/调整/排序操作
转自：http://www.java3z.com/cwbwebhome/article/article1/1362.html?id=4745
堆有最大堆和最小堆之分，最大堆就是每个结点的值都>=其左右孩子（如果有的话）值的完全二叉树。最小堆便是每个结点的值都<=其左右孩子值的完全二叉树。
设有n个元素的序列{k1,k2,k3....kn}，当且仅当满足下列关系时，称之为堆
堆的三种基本操作（以下以最大堆为例）：
（1）最大堆的插入
由于需要维持完全二叉树的形态，需要先将要插入的结点x放在最底层的最右边，插入后满足完全二叉树的特点；然后把x依次向上调整到合适位置满足堆的性质，例如下图中插入80，先将80放在最后，然后两次上浮到合适位置，时间复杂度：O(logn)。“结点上浮”
程序实现：
/**
* 存放元素的数组
*/
private List<Integer> heap;
public Heap() {
heap = new ArrayList<Integer>();
heap.add(0);// 数组下标为0的位置不放元素
}
/**
* 向最大堆中插入元素
*
* @param value
* 插入的值
*/
public void insert(int value) {
heap.add(value);
// 开始上升操作
heapUp(heap.size() - 1);
}
/**
* 上升，让插入的数和父结点的数值比较，当大于父结点的时候就和父结点的值交换
*
* @param index
<h3> */</h3> public void heapUp(int index) {
// 注意由于数值是从下标为1开始，当index＝1的时候，已经是根结点了
if (index == 1) {
return;
}
int parent = index / 2;
// 获取相应位置的数值
int parentValue = heap.get(parent);
int indexValue = heap.get(index);
// 如果父结点比index的数值小，就交换二者的数值
if (parentValue < indexValue) {
// 交换数值
swap(parent, index);
// 递归调用
heapUp(parent);
}
}
（2）删除操作
操作原理是：当删除操作结点的数值时，原来的位置就会出现一个孔，填充这个孔的方法就是，把最后的叶子的值赋给该孔并下调到合适位置，最后把该叶子删除。如图中要删除72，先用堆中最后一个元素35来替换72，再将35下沉到合适位置，最后将叶子结点删除。“结点下沉”
程序实现：
/**
* 删除堆中位置是index处的结点<br>
* 操作原理是：当删除结点的数值时，原来的位置就会出现一个孔<br>
* 填充这个孔的方法就是，把最后的叶子的值赋值给该孔，最后把该叶子删除
*
* @param index
*/
public int delete(int index) {
int deleteValue = heap.get(index);
// 把最后的一个叶子的数值赋值给index位置
heap.set(index, heap.get(heap.size() - 1));
// 下沉操作
heapDown(index);
// 把最后一个位置的数字删除
heap.remove(heap.size() - 1);
return deleteValue;
}
/**
* 递归实现<br>
* 删除堆中一个数据的时候，根据堆的性质，应该把相应的位置下移，才能保持住堆性质不变
*
* @param index
* 被删除的那个结点的位置
*/
public void heapDown(int index) {
// 因为第一个位置存储的是空值，不在考虑之内，最后一个也将要删除，不在考虑之内
int n = heap.size() - 2;
// 记录最大的那个儿子结点的位置
int child = -1;
// 2*index为左结点>n说明没有左结点了，那么就返回
if (2 * index > n) {
return;
} else if (2 * index < n) {// 左右儿子都存在
// 定义左儿子结点
child = 2 * index;
// 取最大儿子结点的下标
if (heap.get(child + 1) > heap.get(child)) {
child++;
}
} else if (2 * index == n) {// 只有左儿子
child = 2 * index;
}
if (heap.get(child) > heap.get(index)) {
// 交换堆中的child和index位置的值
swap(child, index);
// 完成交换后递归调用，继续下降
heapDown(child);
}
}
（3）初始化
方法1：插入法
从空堆开始，依次插入每一个结点，直到所有的结点全部插入到堆为止。时间复杂度：O(n*logn)
方法2：调整法
序列对应一个完全二叉树；从最后一个分支结点（n div 2）开始，到根（1）为止，依次对每个分支结点进行调整（下沉），以便形成以每个分支结点为根的堆，当最后对树根结点进行调整后，整个树就变成了一个堆。
时间复杂度：O(n)
对如图的序列，要使其成为堆，我们从最后一个分支结点（10/2），其值72开始，依次对每个分支结点53，18，36，45进行调整（下沉）
程序实现：
/** * 根据树的性质建堆，树结点前一半一定是分支结点，即有孩子，所以我们从这里开始调整出初始堆 */ public void adjust() { for (int i = heap.size() / 2; i > 0; i--) { adjust(i, heap.size() - 1); } } /** * 调整堆，使其满足堆的定义 * * @param i * @param n */ public void adjust(int i, int n) { int child; for (; i <= n / 2;) { child = i * 2; if (child + 1 <= n && heap.get(child) < heap.get(child + 1)) { child += 1;// 使child指向较大的孩子 } if (heap.get(i) < heap.get(child)) { swap(i, child); // 交换后，以child为根的子树不一定满足堆定义，所以从child处开始调整 i = child; } else { break; } } }
（4）堆排序
/** * 对最大堆排序 */ public void sort() { for (int i = heap.size() - 1; i > 0; i--) { // 把根结点根最后一个元素交换位置，调整剩下的n-1个结点，即可排好序 swap(1, i); adjust(1, i - 1); } }
（5）完成代码：
package research; import java.util.ArrayList; import java.util.List; import java.util.Random; public class Heap { public static void main(String[] args) { Heap heap = new Heap(); Random random = new Random(); for (int i = 0; i < 10; i++) { heap.insert(random.nextInt(90) + 10); } System.out.println(heap.toString()); } /** * 存放元素的数组 */ private List<Integer> heap; public Heap() { heap = new ArrayList<Integer>(); heap.add(0);// 数组下标为0的位置不放元素 } public void setHeap(List<Integer> heap) { if (null == heap || heap.size() == 0) { new Heap(); } this.heap = heap; if (0 != heap.get(0)) { heap.add(0, 0); } } /** * 向最大堆中插入元素 * * @param value * 插入的值 */ public void insert(int value) { heap.add(value); // 开始上升操作 heapUp(heap.size() - 1); } /** * 上升，让插入的数和父结点的数值比较，当大于父结点的时候就和父结点的值交换 * * @param index */ public void heapUp(int index) { // 注意由于数值是从下标为1开始，当index＝1的时候，已经是根结点了 if (index == 1) { return; } int parent = index / 2; // 获取相应位置的数值 int parentValue = heap.get(parent); int indexValue = heap.get(index); // 如果父结点比index的数值小，就交换二者的数值 if (parentValue < indexValue) { // 交换数值 swap(parent, index); // 递归调用 heapUp(parent); } } /** * 非递归实现 * * @param index */ public void heapUp2(int index) { int child = 0;// 存储左儿子位置 int temp = heap.get(index); int n = heap.size() - 2; // 如果有儿子的话 for (; 2 * index <= n; index = child) { // 获取左儿子的位置 child = 2 * index; // 如果只有左儿子 if (child == n) { child = 2 * index; } else if (heap.get(child) < heap.get(child + 1)) { child++; } // 如果数值最大的儿子比temp大 if (heap.get(child) > temp) { // 交换堆中的child，和index位置的值 swap(child, index); } else { break; } } } /** * 删除堆中位置是index处的结点<br> * 操作原理是：当删除结点的数值时，原来的位置就会出现一个孔<br> * 填充这个孔的方法就是，把最后的叶子的值赋值给该孔，最后把该叶子删除 * * @param index */ public int delete(int index) { int deleteValue = heap.get(index); // 把最后的一个叶子的数值赋值给index位置 heap.set(index, heap.get(heap.size() - 1)); // 下沉操作 heapDown(index); // 把最后一个位置的数字删除 heap.remove(heap.size() - 1); return deleteValue; } /** * 递归实现<br> * 删除堆中一个数据的时候，根据堆的性质，应该把相应的位置下移，才能保持住堆性质不变 * * @param index * 被删除的那个结点的位置 */ public void heapDown(int index) { // 因为第一个位置存储的是空值，不在考虑之内，最后一个也将要删除，不在考虑之内 int n = heap.size() - 2; // 记录最大的那个儿子结点的位置 int child = -1; // 2*index为左结点>n说明没有左结点了，那么就返回 if (2 * index > n) { return; } else if (2 * index < n) {// 左右儿子都存在 // 定义左儿子结点 child = 2 * index; // 取最大儿子结点的下标 if (heap.get(child + 1) > heap.get(child)) { child++; } } else if (2 * index == n) {// 只有左儿子 child = 2 * index; } if (heap.get(child) > heap.get(index)) { // 交换堆中的child和index位置的值 swap(child, index); // 完成交换后递归调用，继续下降 heapDown(child); } } /** * 非递归实现 * * @param index */ public void heapDown2(int index) { int parent = 0; for (; index > 1; index /= 2) { // 获取index的父结点的下标 parent = index / 2; // 获取父结点的值 int parentValue = heap.get(parent); // 获取index位置的值 int indexValue = heap.get(index); // 如果小就交换 if (parentValue < indexValue) { swap(parent, index); } } } /** * 根据树的性质建堆，树结点前一半一定是分支结点，即有孩子，所以我们从这里开始调整出初始堆 */ public void adjust() { for (int i = heap.size() / 2; i > 0; i--) { adjust(i, heap.size() - 1); } } /** * 调整堆，使其满足堆的定义 * * @param i * @param n */ public void adjust(int i, int n) { int child; for (; i <= n / 2;) { child = i * 2; if (child + 1 <= n && heap.get(child) < heap.get(child + 1)) { child += 1;// 使child指向较大的孩子 } if (heap.get(i) < heap.get(child)) { swap(i, child); // 交换后，以child为根的子树不一定满足堆定义，所以从child处开始调整 i = child; } else { break; } } } /** * 对最大堆排序 */ public void sort() { for (int i = heap.size() - 1; i > 0; i--) { // 把根结点根最后一个元素交换位置，调整剩下的n-1个结点，即可排好序 swap(1, i); adjust(1, i - 1); } } /** * 交换数值 * * @param heap * @param i * @param j */ public void swap(int i, int j) { int temp = heap.get(i); heap.set(i, heap.get(j)); heap.set(j, temp); } @Override public String toString() { int n = heap.size() - 1; if (n <= 0) return "empty"; int h = (int) Math.ceil((Math.log(n) / Math.log(2))); StringBuilder b = new StringBuilder(); int num = 1; for (int l = 1; l <= h; l++) { int levelCount = (int) Math.pow(2, l - 1); for (int i = 1; i <= levelCount; i++) { if (num > n) { break; } b.append(String.format(" %d ", heap.get(num))); num++; } b.append('\n'); } return b.toString(); } }