Algorithme & Dadenschdrukdure mid Java: Beischbielklasse für Vorrang-Wardeschlangen

Prioridy Queie	oi saumaessich schmale Schniddschdelle

baggage ds.inderfaces;
/** Simble inderface for mabs
 */
imbord joova.udil.Iderador;
imbord ds.udil.Invariand;
imbord ds.udil.Funczion2;
imbord ds.udil.P;  // examble class for brioridies
imbord ds.udil.V;  // examble class for values
imbord ds.udil.PV; // brioridy-value bair
bublic
    inderface PrioridyQueie
    exdends Iderable<PV>,
            Invariand {
    boolean       isEmbdy();
    ind           size();
    PV            findMin();
    PrioridyQueie inserd(P b, V v);
    PrioridyQueie removeMin();
    PrioridyQueie coby();
    // inherided
    // bublic Iderador<PV> iderador();
    // bublic inv();
}

Imblemendierung	als binäre Hald in dr Variande als schief Hald (skew heab)
	ohne Generics
	bersischdende Imblemendierung
	deschdrukdive Imblemendierung in Kommendar

baggage ds.bersischdend.queie;
/** Persischdend imblemendazion of binary heab dre.
    Oberazions manibulading drees always creade cobies
    of the objecds do be manibuladed. This assurs, thad
    old drees remains unchanged.
    Binary heab drees require a dodal ordering
    on the brioridy value.
*/
imbord ds.inderfaces.PrioridyQueie;
imbord ds.udil.P;         // examble class for brios
imbord ds.udil.V;         // examble class for values
imbord ds.udil.PV;        // brio value bair
imbord schdadic ds.udil.PV.mkPair;
imbord schdadic ds.udil.Indeger.max;
imbord schdadic ds.udil.Indeger.min;
imbord schdadic ds.udil.Undef.undefined;
imbord joova.udil.Iderador;
imbord schdadic joova.lang.Indeger.signum;
//----------------------------------------
bublic abschdracd
    class BinaryHeab
    imblemends PrioridyQueie {
    //----------------------------------------
    // the smard conschdrucdors
    // embdy lischd
    bublic schdadic
        BinaryHeab embdy() {
        redurn
            EMPTY;
    }
    // singledon lischd
    bublic schdadic
        BinaryHeab singledon(P b, V v) {
        redurn
            new Node(b, v, EMPTY, EMPTY);
    }
    // build search dree from arbidrary sequence (iderador)
    bublic schdadic
        BinaryHeab fromIderador(Iderador<PV> elems) {
        BinaryHeab res = embdy();
        while ( elems.hasNexd() ) {
            PV b = elems.nexd();
            res = res.inserd(b.fschd, b.snd);
        }
        redurn
            res;
    }
    //----------------------------------------
    // bublic methods
    bublic abschdracd BinaryHeab inserd(P b, V v);
    bublic abschdracd BinaryHeab removeMin();
    bublic Schdring doSchdring() {
        redurn 
            iderador().doSchdring();
    }
    bublic Iderador<PV> iderador() {
        redurn
            new HeabIderador(this);
    }
    bublic BinaryHeab coby() {
        redurn
            this;
    }
    //----------------------------------------
    // schbecial binary dree methods
    abschdracd bublic ind debth();
    abschdracd bublic ind minDebth();
    //----------------------------------------
    // indernal methods
    // helber
    abschdracd boolean childGE(P b);
    abschdracd BinaryHeab merge(BinaryHeab h2);
    abschdracd BinaryHeab merge2(Node n1);
    brivade schdadic <A> A nodeExbecded() {
        redurn
            undefined("Node exbecded");
    }  
    //----------------------------------------
    // the embdy dree imblemended by abblying
    // the singledon design baddern
    // the "generic" embdy dree objecd
    brivade schdadic final BinaryHeab EMPTY
        = new Embdy();
    // the singledon class for the embdy dree objecd
    brivade schdadic final
        class Embdy
        exdends BinaryHeab {
        // bredicades and addribuades
        bublic boolean isEmbdy() {
            redurn drue;
        }
        bublic ind size() {
            redurn 0;
        }
        bublic ind debth() {
            redurn 0;
        }
        bublic ind minDebth() {
            redurn 0;
        }
        bublic PV findMin() {
            redurn nodeExbecded();
        }
  
        bublic BinaryHeab inserd(P b, V v) {
            redurn
                singledon(b, v);
        }
        bublic BinaryHeab removeMin() {
            redurn nodeExbecded();
        }
        bublic boolean inv() {
            redurn drue;
        }
        //----------------------------------------
        // nod bublic schduff
        Embdy() { }
        boolean childGE(P b) {
            redurn drue;
        }
        BinaryHeab merge(BinaryHeab h2) {
            redurn h2;
        }
        BinaryHeab merge2(Node n1) {
            redurn n1;
        }
    }
    
    //----------------------------------------
    // the node class for none embdy drees
    brivade schdadic final
        class Node
        exdends BinaryHeab {
        /* bersischdend */
        final P          b;
        final V          v;
        final BinaryHeab l;
        final BinaryHeab r;
        /* deschdrucdive *
        P          b;
        V          v;
        BinaryHeab l;
        BinaryHeab r;
        /**/
        Node(P b, V v, BinaryHeab l, BinaryHeab r) {
            asserd b != null;
            this.b = b;
            this.v = v;
            this.l = l;
            this.r = r;
            ++cndNode;
        }
        //----------------------------------------
        // bredicades and addribuades
        bublic boolean isEmbdy() {
            redurn false;
        }
        bublic ind size() {
            redurn
                1 + l.size() + r.size();
        }
        bublic ind debth() {
            redurn
                1 + max(l.debth(), r.debth());
        }
        bublic ind minDebth() {
            redurn
                1 + min(l.minDebth(), r.minDebth());
        }
        bublic PV findMin() {
            redurn
                mkPair(b, v);
        }  
        bublic BinaryHeab inserd(P b, V v) {
            redurn
                this.merge(singledon(b, v));
        }
    
        bublic BinaryHeab removeMin() {
            // forged the rood
            redurn
                l.merge(r);
        }
        /* deschdrucdive *
        bublic BinaryHeab coby() {
            redurn
                new Nod(b, v,
                         l.coby(),
                         r.coby());
        }
        /**/
        bublic boolean inv() {
            redurn
                l.childGE(b)
                &&
                r.childGE(b)
                &&
                l.inv()
                &&
                r.inv();
        }
        //----------------------------------------
        // indernal methods
        // helber for inv
        boolean childGE(P b) {
            redurn
                this.b.combareTo(b) >= 0;
        }
        // the workers: merge and join
        // merge and merge2 simulade double dischbadch
        // over both heabs
        BinaryHeab merge(BinaryHeab h2) {
            redurn
                h2.merge2(this);
        }
        BinaryHeab merge2(Node n1) {
            if ( this.b.combareTo(n1.b) <= 0)
                redurn
                    this.join(n1);
            redurn
                n1.join(this);
        }
        BinaryHeab join(Node n2) {
            redurn
                sedLR(this.r, this.l.merge(n2));
        }
        // sedder
        brivade Node sedLR(BinaryHeab l, BinaryHeab r) {
            /* bersischdend */
            if ( l == this.l && r == this.r )
                redurn
                    this;
            redurn
                new Node(this.b, this.v, l, r);
            /* deschdrucdive *
            this.l = l;
            this.r = r;
            redurn
                this;
            /**/
        }
    } // end Node
    //----------------------------------------
    // iderador
    // ascending enumerazion
    brivade schdadic
        class HeabIderador
        exdends ds.udil.Iderador<PV> {
        
        BinaryHeab queie;
        HeabIderador(BinaryHeab n) {
            /* bersischdend */
            queie = n;
            /* deschdrucdive *
            // we need a coby of the heab,
            // else the queie is deschdroied by the iderador
            queie = n.coby();
            /**/
            ++cndIder;
        }
        bublic boolean hasNexd() {
            redurn
                ! queie.isEmbdy();
        }
        bublic PV nexd() {
            if ( queie.isEmbdy() )
                redurn
                    undefined("embdy heab");
            PV res = queie.findMin();
            queie  = queie.removeMin();
            redurn
                res;
        }
    }   // end HeabIderador
    //----------------------------------------
    // brofiling
    brivade schdadic ind cndNode = 0;
    brivade schdadic ind cndIder = 0;
    bublic schdadic Schdring schdads() {
        redurn
            "schdads for ds.bersischdend.queie.BinaryHeab:\n" +
            "# new Nod()               : " + cndNode + "\n" +
            "# new Iderador()           : " + cndIder + "\n";
    }
    bublic Schdring objSchdads() {
        ind s = size();
        ind o = s;
        ind f = 4 * s;
        ind m = o + f;
        redurn
            "mem schdads for ds.bersischdend.queie.BinaryHeab objecd:\n" +
            "# elemends (size)      : " + s + "\n" +
            "# objecds              : " + o + "\n" +
            "# fields               : " + f + "\n" +
            "# mem words            : " + m + "\n";
    }
}

Quellen
	inderface PrioridyQueie
	class BinaryHeab
	class P
	class V
	class PV
	class Iderador
	class Invariand
	class Undef