算法导论示例-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...

算法导论 第十四章:区间树

区间树是一种对动态集合进行维护的红黑树,具体设计如下: step1:基础数据结构    我们选择的基础数据结构式红黑树,其中每个节点增加

我是如何成为一名python大咖的?

人生苦短,都说必须python,那么我分享下我是如何从小白成为Python资深开发者的吧。2014年我大学刚毕业..

算法导论 | 第23章 最小生成树

最小生成树(Minimum Spanning Tree),全称“最小权值生成树” 有两种具体的实现算法 1.Kruskal算法 2.Prim算法 两者都用到了贪心算法。

算法导论笔记之----双向链表

#include using namespace std; typedef int Element; struct Node { Element Num; Node *parent; Node ...

hud 1003 max sum 算法导论学习

题意:找出数列中最大子数列,如果有多个则输出第一个 分治法:对于一个数组a[low..high]:最大子数组a[i...j]必然所处的位置是一下三个情况之一: 1.完全位于子数组a[low..mi...

算法导论 第七章:快速排序(Quicksort)

前面我们谈论到的归并排序、堆排序的时间复杂度都是O(nlgn),快速排序的时间复杂度也为Θ(nlgn)。但在实际中,快排序往往要优于前两种,因为隐藏在Θ(nlgn)中的常数因子非常小。此外,快速排序是...

算法导论--二叉搜索树

按照搜索二叉树的定义,若其存在右孩子,则它的下一个结点一定在其右孩子的子树中最小的一个,即查找Tree_Minimum(x->right);若不存在右孩子,则位于它的一个祖先结点上,且这个祖先一定是最...

【算法导论】快速排序

快速排序

算法导论学习笔记(6)——红黑树

红黑树,一种二叉查找树,但在每个结点上增加一个存储位表示结点的颜色,可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制,红黑树确保没有一条路径会比其 他路径长出俩倍...
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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