最大堆的插入/删除/调整/排序操作

最新推荐文章于 2024-10-08 21:03:59 发布

Sayangnala

最新推荐文章于 2024-10-08 21:03:59 发布

阅读量3.7k

点赞数 2

分类专栏：算法文章标签：排序堆

算法专栏收录该内容

9 篇文章 0 订阅

订阅专栏

转自：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();
	}
}