算法导论示例-PriorityQueue

原创 2006年06月04日 01:30:00
import java.util.EmptyStackException;

/**
 * Introduction to Algorithms, Second Edition 
 * 6.4 Priority queues
 * 
 * @author 土豆爸爸
 * 
 */
public class PriorityQueue<KeyType extends Comparable<KeyType>, T extends IPriorityQueueElement<KeyType>> {
    T[] array;

    int heapSize;

    /**
     * 构造函数
     * @param size 初始数组大小
     */
    @SuppressWarnings("unchecked")
    public PriorityQueue(int size) {
        array = (T[]) new IPriorityQueueElement[size];
    }

    /**
     * 获取当前heap中的最大值
     * 
     * @return 最大值
     */
    public T maximum() {
        return array[0];
    }

    /**
     * 获取当前heap中的最大值,并从heap中删除最大值
     * @return 最大值
     */
    public T extractMax() {
        if (heapSize < 1) {
            throw new EmptyStackException();
        }
        T max = array[0];
        array[0] = array[heapSize - 1];
        heapSize--;
        maxHeapify(0);
        return max;
    }

    /**
     * 插入一个元素
     * @param e
     */
    @SuppressWarnings("unchecked")
    public void insert(T e) {
        if (heapSize == array.length) {
            T[] newArray = (T[]) new IPriorityQueueElement[array.length * 2];
            System.arraycopy(array, 0, newArray, 0, array.length);
            array = newArray;
        }
        int i = heapSize++;
        array[i] = e;
        int p = parent(i); // 父结点索引
        while (i > 0 && array[p].getKey().compareTo(array[i].getKey()) < 0) {
            T temp = array[i];
            array[i] = array[p];
            array[p] = temp;
            i = p;
            p = parent(i);
        }
    }

    /**
     * 使数组的第i个元素按max heap规则重排
     * 
     * @param i
     *            元素索引
     */
    private void maxHeapify(int i) {
        int l = left(i);
        int r = right(i);
        int largest; // 当前结点/左子结点/右子结点中最大值的索引
        if (l < heapSize && array[l].getKey().compareTo(array[i].getKey()) > 0) {
            largest = l;
        } else {
            largest = i;
        }

        if (r < heapSize
                && array[r].getKey().compareTo(array[largest].getKey()) > 0) {
            largest = r;
        }

        if (largest != i) {
            // 如果最大值不是当前结点,进行交换
            T temp = array[i];
            array[i] = array[largest];
            array[largest] = temp;
            // 递归调用,直到当前结点比其子结点大
            maxHeapify(largest);
        }

    }

    /**
     * 计算结点索引为i的元素的父结点的索引
     * 
     * @param i
     *            当前索引
     * @return 父结点的索引
     */
    private int parent(int i) {
        return (i + 1) / 2 - 1;
    }

    /**
     * 计算结点索引为i的元素的左子结点的索引
     * 
     * @param i
     *            当前索引
     * @return 左子结点的索引
     */
    private int left(int i) {
        return 2 * i + 1;
    }

    /**
     * 计算结点索引为i的元素的右子结点的索引
     * 
     * @param i
     *            当前索引
     * @return 右子结点的索引
     */
    private int right(int i) {
        return 2 * i + 2;
    }
}

public interface IPriorityQueueElement<KeyType extends Comparable<KeyType>>{
    KeyType getKey();
}

import junit.framework.TestCase;

import junit.framework.TestCase;

public class PriorityQueueTest extends TestCase {
    class Element implements IPriorityQueueElement<Integer> {
        Integer key;

        public Element(Integer key) {
            this.key = key;
        }

        public Integer getKey() {
            return key;
        }
    }

    public void testMaximum() {
        PriorityQueue<Integer, Element> queue = new PriorityQueue<Integer, Element>(2);
        queue.insert(new Element(1));
        queue.insert(new Element(2));
        assertEquals(new Integer(2), queue.maximum().getKey());
        queue.insert(new Element(10));
        assertEquals(new Integer(10), queue.maximum().getKey());
        queue.insert(new Element(3));
        assertEquals(new Integer(10), queue.maximum().getKey());
    }
    
    public void testExtractMax() {
        PriorityQueue<Integer, Element> queue = new PriorityQueue<Integer, Element>(2);
        queue.insert(new Element(1));
        queue.insert(new Element(2));
        assertEquals(new Integer(2), queue.extractMax().getKey());
        assertEquals(new Integer(1), queue.maximum().getKey());
    }
}

相关文章推荐

链式哈希表(Hash Table)--算法导论示例

In computer science, a hash table is an associative array data structure that associates keys with v...

算法导论 之 B树(B-树) - 创建、插入[C语言]

在计算机科学中,B树在查找、访问、插入、删除操作上时间复杂度为O(log2~n)(2为底数 n为对数),不像自平衡二叉查找树,其可以有效的优化系统对大块的数据读写的性能,其通常在数据库和文件系统中被使...

【算法导论之六】二叉排序树(Binary Search Tree)

1. 二叉排序树的定义     它或者是一棵空树;或者是具有下列性质的二叉树:            (1)若左子树不空,则左子树上所有结点的值均小于它的根结点的值;            (2)...

二叉查找树(来自算法导论)

#include using namespace std; typedef struct TreeNode{ int val; TreeNode*left; TreeNode*r...
  • huruzun
  • huruzun
  • 2014年03月13日 15:56
  • 664

《算法导论》15-3:编辑距离

(1)初始化: cost[i][0] = deleteCost * i cost[0][j] = insertCost * i(2)递推公式: (3)kill操作 public class...

算法导论—中位数与顺序统计量

华电北风吹 天津大学认知计算与应用重点实验室 日期:2015/7/7 一、选择最大值或者最小值的最优算法 对于长度为n的数组,已证找最大值或者最小值比较操作下界就是n-1。所以只需要让第一个...

《算法导论》第12章 二叉查找树

摘要:   本章介绍了二叉查找树的概念及操作。主要内容包括二叉查找树的性质,如何在二叉查找树中查找最大值、最小值和给定的值,如何找出某一个元素的前驱和后继,如何在二叉查找树中进行插入和删除操作。在二...

【算法导论】02——渐近符号、递归及解法

渐近符号 1、Θ记号  Θ(g(n)) = { f(n) : 若存在正常数c1,c2和n0,使对所有n>=n0时有0 其效果相当于删除f(n)中的低阶项,并忽略最高阶项的系数。 ...
  • muyimo
  • muyimo
  • 2014年07月27日 22:10
  • 727

算法导论 第7章 快速排序

一、概念 快速排序是基于分治模式的,选择一个数作为主元,经过一遍扫描,所有小于主元的数放在主元的左边,大于主元的数放在主元的右边,这样就划分成了两组数据。然后对两组数分别进行快排。 快排的运行时间与划...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:算法导论示例-PriorityQueue
举报原因:
原因补充:

(最多只允许输入30个字)