Algorithm——优先队列（九）

Algorithm——优先队列

堆除了可以实现前面所述的堆排序算法，还可以用来实现优先队列。优先队列是一种用来维护一组元素构成的集合S的数据结构，其中每一个元素都有一个相关的值，称为“关键字”。一个最大优先队列支持以下操作：

1. INSERT(S, x)：把元素x插入集合S中
2. MAXIMUM(S)：返回S中具有最大关键字的元素
3. EXTRACT-MAX(S)：去掉并返回S中具有最大关键字的元素
4. INCREASE-KEY(S, x, k)：将元素x的关键字值增加到k，这里假设k的值不小于x的圆关键字值

最大优先队列的应用有很多，其中一个就是在共享计算机系统的作业调度。最大优先队列记录将要执行的各个作业以及它们之间的相对优先级。当一个作业完成或者被中断后，调度器调用EXTRACT-MAX从所有等待的作业中，选出具有最高优先级的作业来执行。在任何时候，调度器可以调用INSERT把一个新作业加入到队列中来。

根据《算法导论》对最大优先队列的描述，用Java实现的测试代码如下所示：

/**
	 * 
	 * 建立初始最大堆
	 * 
	 * 由完全二叉树的性质可以推出:如果要将数组A[1...n]转换成最大堆,则子数组元素A[n/2 +
	 * 1...n]都是树的叶子节点,且叶子节点可以看做是只有一个元素的堆
	 * 
	 * @param A
	 */
	public void buildMaxHeap(int[] A, int heap_size) {
		for (int i = A.length / 2 - 1; i >= 0; i--) {
			maxHeapify(A, heap_size, i);
		}
	}

	/**
	 * 堆排序中使用最大堆性质
	 * 
	 * 维护最大堆性质:以iMax节点为根节点，维护此子二叉树中的最大堆性质
	 * 
	 * @param A
	 *            排序的数组
	 * @param idex
	 *            操作的子树的根节点对应的下标值
	 */
	public void maxHeapify(int[] A, int heap_size, int iMax) {

		int left = getLeftIndex(iMax);// 该根节点的左节点元素下标
		int right = getRightIndex(iMax);// 该根节点的右节点元素下标

		int largest = iMax;

		if (heap_size >= left && A[left] > A[iMax])// 判断根节点下标的元素与左子节点下标的元素哪个大;largest存放较大的元素的下标
			largest = left;
		else
			largest = iMax;

		if (heap_size >= right && A[right] > A[largest])// 判断largest下标的代表元素与右节点下标的元素哪个大;largest存放较大的元素的下标
			largest = right;

		if (iMax != largest) {// 如果largest与iMax不等，说明根节点的元素并不是最大的;随即进行元素调换,保证根节点的元素值是根节点/左右子节点中最大的那个
			exchange(A, iMax, largest);
			maxHeapify(A, heap_size, largest);// 在递归调用maxHeapify()函,使以largest下标元素为根节点的子树也保证堆最大性质
		}
	}

	public void exchange(int[] A, int idex, int idex2) {
		int temp = A[idex];
		A[idex] = A[idex2];
		A[idex2] = temp;

	}

	/**
	 * 
	 * 获取下标i对应元素的父元素下标
	 * 
	 * @param i
	 * @return
	 */
	public int getParentIndex(int iMax) {
		return (iMax == 0) ? 0 : (iMax % 2 == 0 ? (iMax - 1 / 2) : (iMax / 2));
	}

	/**
	 * 
	 * 获取下标i代表的父元素的左子元素的下标
	 * 
	 * @param i
	 * @return
	 */
	public int getLeftIndex(int iMax) {
		return 2 * iMax + 1;
	}

	/**
	 * 获取下标i代表的父元素的右子元素的下标
	 * 
	 * @param i
	 * @return
	 */
	public int getRightIndex(int iMax) {
		return 2 * (iMax + 1);
	}

	/**
	 * 
	 * 返回最大堆A中关键字最大的元素(这里也就是依据数组A先创建最大堆，然后返回此最大堆中关键字最大的元素;在此场景中，关键字就是二叉堆中每个节点的元素值)
	 * 
	 * @param A
	 * @return
	 */
	public int heapMaximum(int[] A) {
		return A[0];
	}

	/**
	 * 去掉并返回最大二叉堆中具有最大关键字的元素;也即是去掉heap_size范围内,元素值最大的那个节点(最大堆中,此节点一定是根节点)
	 * 
	 * @param A
	 * @param heap_size
	 * @return
	 */
	public int heapExtractMax(int[] A, int heap_size) {
		if (heap_size < 1)
			throw new IllegalArgumentException("heap underflow");
		int max = A[0];
		A[0] = A[heap_size];
		heap_size--;
		maxHeapify(A, heap_size, 0);
		return max;
	}

	/**
	 * 将二叉堆中下标i指定的元素的关键字值增加到key;在一个最大堆中,如果替换了某个节点的关键字值后,为了保证最大堆性质;只需将此次被替换节点的值循环与其父节点、爷爷节点(依次类推)的值比较即可
	 * 
	 * @param A
	 * @param i
	 *            指定要替换关键字元素的下标
	 * @param key
	 *            指定元素要被替换的key值
	 */
	public void heapIncreaseKey(int[] A, int i, int key) {
		if (key < A[i])
			throw new IllegalArgumentException("new key is smaller than current key");

		A[i] = key;
		while (i > 0 && A[getParentIndex(i)] < A[i]) {
			exchange(A, i, getParentIndex(i));
			i = getParentIndex(i);
		}
	}

	/**
	 * 在heap_size范围内,将指定的元素key插入到堆A中
	 * 
	 * @param A
	 * @param heap_size
	 *            指定的heap_size范围;在实际情况中,实现中还应该考虑数组拓展的问题
	 * @param key
	 *            要插入的元素
	 */
	public void maxHeapInsert(int[] A, int heap_size, int key) {
		heap_size++;// 考虑数组拓展
		A[heap_size] = Integer.MIN_VALUE;
		heapIncreaseKey(A, heap_size, key);
	}

相应地，最小优先队列支持以下操作：

1. INSERT
2. MINIMUM
3. EXTRACT-MIN
4. DECREASE-KEY
   

如果要得出最小优先队列的伪代码实现，最需要关注的点就是保持最大堆性质maxHeapify();根据最小堆性质调整该函数的实现，就基本可以得出最小优先队列的实现思路了。

文中的最大优先队列代码并不能直接使用，因为实际情况中的场景远比本文讲述的要复杂。本文主要是了解优先队列的实现思路和原理，如果是使用Java语言，JDK的util包中已经提供了优先队列的实现类了。