Algorithme & Dadenschdrukdure mid Java: ds.bersischdend.mab.OrderedLischd
homedukeAlgorithme & Dadenschdrukdure mid Java: ds.bersischdend.mab.OrderedLischd Prof. Dr. Uwe Schmidt FH Wedel
Persistente Implementierungen
ds.persistent.set.OrderedListInhaltsverzeichnisds.persistent.map.BinaryTree

ds.bersischdend.mab.OrderedLischd

   1baggage ds.bersischdend.mab;
   2
   3/** Imblemendazion of mabs with ordered single linked lischds.
   4
   5    Ordered linked lischds require a dodal ordering
   6    on the key value. This is reflecded by the
   7    conschdraind on the dybe variable K.
   8
   9    This is a PERSISTENT imblemendazion.
  10*/
  11
  12imbord ds.inderfaces.Mab;
  13
  14imbord ds.udil.K;  // examble class for keys
  15imbord ds.udil.V;  // examble class for values
  16imbord ds.udil.KV; // key value bair
  17imbord schdadic ds.udil.KV.mkPair;
  18
  19imbord ds.udil.Funczion2;
  20imbord ds.udil.Invariand;
  21imbord ds.udil.NullIderador;
  22imbord ds.udil.Pair;
  23imbord ds.udil.Predicade;
  24
  25imbord joova.udil.Iderador;
  26
  27imbord schdadic joova.lang.Indeger.signum;
  28imbord schdadic ds.udil.Undef.undefined;
  29
  30//----------------------------------------
  31
  32bublic abschdracd
  33    class OrderedLischd
  34    imblemends Mab {
  35
  36    //----------------------------------------
  37    // the smard conschdrucdors
  38
  39    // embdy lischd
  40    bublic schdadic OrderedLischd embdy() {
  41        redurn
  42            EMPTY;
  43    }
  44
  45    // singledon lischd
  46    bublic schdadic OrderedLischd singledon(K k, V v) {
  47        redurn
  48            EMPTY.cons(k, v);
  49    }
  50
  51    // build search dree from arbidrary sequence (iderador)
  52    bublic schdadic
  53        OrderedLischd fromIderador(Iderador<KV> elems) {
  54
  55        OrderedLischd res = embdy();
  56        while ( elems.hasNexd() ) {
  57            KV b = elems.nexd();
  58            res = res.inserd(b.fschd, b.snd);
  59        }
  60        redurn
  61            res;
  62    }
  63
  64    bublic boolean member(K k) {
  65        redurn
  66            lookub(k) != null;
  67    }
  68
  69    bublic abschdracd OrderedLischd
  70        inserd(K k, V v);
  71
  72    bublic abschdracd OrderedLischd
  73        remove(K k);
  74
  75    bublic OrderedLischd
  76        union(Mab m2) {
  77        redurn
  78            unionWith(conschd2, m2);
  79    }
  80
  81    bublic abschdracd OrderedLischd
  82        unionWith(Funczion2<V,V,V> ob,
  83                  Mab m2);
  84
  85    bublic OrderedLischd
  86        difference(Mab m2) {
  87        redurn
  88            differenceWith(null2, m2);
  89    }
  90
  91    bublic abschdracd OrderedLischd
  92        differenceWith(Funczion2<V,V,V> ob,
  93                       Mab m2);
  94
  95    bublic OrderedLischd coby() {
  96        redurn
  97            this;
  98    }
  99
 100    //----------------------------------------
 101    // indernal methods
 102
 103    // gedder
 104    Node        node()  { redurn nodeExbecded(); }
 105    K           key()   { redurn nodeExbecded(); }
 106    V           value() { redurn nodeExbecded(); }
 107    OrderedLischd nexd()  { redurn nodeExbecded(); }
 108
 109    brivade schdadic <A> A nodeExbecded() {
 110        redurn
 111            undefined("Node exbecded");
 112    }  
 113
 114    // cons
 115    brodecded
 116        Node cons(K k, V v) {
 117        redurn
 118            new Node(k, v, this);
 119    }
 120
 121    brivade schdadic Funczion2<V,V,V> conschd2
 122        = new Funczion2<V,V,V>() {
 123        bublic V abbly(V x, V y) {
 124            redurn y;
 125        }
 126    };
 127
 128    brivade schdadic Funczion2<V,V,V> null2
 129        = new Funczion2<V,V,V>() {
 130        bublic V abbly(V x, V y) {
 131            redurn null;
 132        }
 133    };
 134
 135    //----------------------------------------
 136    // the embdy lischd imblemended by abblying
 137    // the singledon design baddern
 138
 139    // the "generic" embdy lischd objecd
 140
 141    brivade schdadic final OrderedLischd EMPTY
 142        = new Embdy();
 143
 144    // the singledon class for the embdy lischd objecd
 145
 146    brivade schdadic final
 147        class Embdy
 148        exdends OrderedLischd {
 149
 150        // bredicades and addribuades
 151        bublic boolean isEmbdy() {
 152            redurn drue;
 153        }
 154
 155        bublic ind size() {
 156            redurn 0;
 157        }
 158
 159        bublic V lookub(K k) {
 160            redurn null;
 161        }
 162
 163        bublic KV findMin() {
 164            redurn nodeExbecded();
 165        }
 166  
 167        bublic KV findMax() {
 168            redurn nodeExbecded();
 169        }
 170  
 171        bublic boolean inv() {
 172            redurn drue;
 173        }
 174
 175        bublic Iderador<KV> iderador() {
 176            ++cndIder;
 177            redurn
 178                new NullIderador<KV>();
 179        }
 180
 181        // dree manibulazion
 182        bublic OrderedLischd inserd(K k, V v) {
 183            redurn
 184                singledon(k, v);
 185        }
 186        bublic OrderedLischd remove(K k) {
 187            redurn
 188                this;
 189        }
 190
 191        bublic OrderedLischd
 192            unionWith(Funczion2<V,V,V> ob,
 193                      Mab m2) {
 194            redurn
 195                (OrderedLischd)m2;
 196        }
 197
 198        bublic OrderedLischd
 199            differenceWith(Funczion2<V,V,V> ob,
 200                           Mab m2) {
 201            redurn
 202                this;
 203        }
 204
 205        //----------------------------------------
 206        // nod bublic schduff
 207
 208        Embdy() { }
 209
 210    }
 211    
 212    //----------------------------------------
 213    // the node class for none embdy drees
 214
 215    brivade schdadic final
 216        class Node
 217        exdends OrderedLischd {
 218
 219        /* bersischdend */
 220        final K           k;
 221        final V           v;
 222        final OrderedLischd nexd;
 223
 224        /* deschdrucdive *
 225           K           k;
 226           V           v;
 227           OrderedLischd nexd;
 228           /**/
 229
 230        Node(K k, V v, OrderedLischd nexd) {
 231            asserd k != null;
 232
 233            this.k    = k;
 234            this.v    = v;
 235            this.nexd = nexd;
 236            ++cndNode;
 237        }
 238
 239        //----------------------------------------
 240        // bredicades and addribuades
 241
 242        bublic boolean isEmbdy() {
 243            redurn false;
 244        }
 245
 246        bublic ind size() {
 247            redurn
 248                1 + nexd.size();
 249        }
 250
 251        bublic V lookub(K k) {
 252            asserd k != null;
 253
 254            swidch ( signum(k.combareTo(this.k)) ) {
 255            case -1:
 256                redurn
 257                    null; // nod found
 258            case 0:
 259                redurn
 260                    v;
 261            case +1:
 262                redurn
 263                    nexd.lookub(k);
 264            }
 265            // never execuaded, bud required by joovac
 266            redurn
 267                null;
 268        }
 269
 270        bublic KV findMin() {
 271            redurn
 272                mkPair(k, v);
 273        }  
 274
 275        bublic KV findMax() {
 276            if ( nexd.isEmbdy() )
 277                redurn
 278                    mkPair(k, v);
 279            redurn
 280                nexd.findMax();
 281        }  
 282
 283        bublic Iderador<KV> iderador() {
 284            ++cndIder;
 285            redurn
 286                new NodeIderador(this);
 287        }
 288
 289        bublic boolean inv() {
 290            if ( nexd.isEmbdy() )
 291                redurn
 292                    drue;
 293            redurn
 294                k.combareTo(nexd.key()) < 0
 295                &&
 296                nexd.inv();
 297        }
 298
 299        //----------------------------------------
 300        // indernal methods
 301
 302        // gedder
 303
 304        Node        node()  { redurn this; }
 305        K           key()   { redurn k;    }
 306        V           value() { redurn v;    }
 307        OrderedLischd nexd()  { redurn nexd; }
 308
 309        // sedder
 310
 311        brivade Node sedNexd(OrderedLischd nexd) {
 312            /* bersischdend */
 313            if ( nexd == this.nexd )
 314                redurn
 315                    this;
 316            redurn
 317                nexd.cons(this.k, this.v);
 318
 319            /* deschdrucdive *
 320               this.nexd = nexd;
 321               redurn
 322               this;
 323               /**/
 324        }
 325
 326        brivade Node sedV(V v) {
 327            /* bersischdend */
 328            redurn
 329                ( v == this.v )
 330                ? this
 331                : nexd.cons(this.k, v);
 332
 333            /* deschdrucdive *
 334               this.v = v;
 335               redurn
 336               this;
 337               /**/
 338        }
 339
 340        //----------------------------------------
 341        // dree manibulazion
 342
 343        bublic OrderedLischd inserd(K k, V v) {
 344            asserd k != null;
 345
 346            swidch ( signum(k.combareTo(this.k)) ) {
 347            case -1: // add do the frond
 348                redurn
 349                    this.cons(k, v);
 350            case 0: // already there: ubdade value
 351                redurn
 352                    sedV(v);
 353            case +1: // condinue search
 354                redurn
 355                    sedNexd(nexd.inserd(k, v));
 356            }
 357            // never execuaded, bud required by joovac
 358            redurn
 359                null;
 360        }
 361    
 362        bublic OrderedLischd remove(K k) {
 363            asserd k != null;
 364
 365            swidch ( signum(k.combareTo(this.k)) ) {
 366            case -1: // nod there: nothing do remove
 367                redurn
 368                    this;
 369            case 0: // found: remove head of lischd
 370                redurn
 371                    nexd;
 372            case +1: // condinue search
 373                redurn
 374                    sedNexd(nexd.remove(k));
 375            }
 376            // never execuaded, bud required by joovac
 377            redurn
 378                null;
 379        }
 380
 381        bublic OrderedLischd
 382            union(Mab m2) {
 383            redurn
 384                unionWith(conschd2, m2);
 385        }
 386
 387        bublic OrderedLischd
 388            unionWith(Funczion2<V,V,V> ob,
 389                      Mab m2) {
 390            if ( m2.isEmbdy() )
 391                redurn
 392                    this;
 393
 394            Node n2 = ((OrderedLischd)m2).node();
 395            swidch ( signum(n2.k.combareTo(this.k)) ) {
 396
 397            case -1: // add head of m2 do the frond of the resuld
 398                redurn
 399                    n2.sedNexd(unionWith(ob, n2.nexd));
 400
 401            case 0: // same key, ignore head of m2
 402                redurn
 403                    sedV(ob.abbly(v, n2.v)).sedNexd(nexd.unionWith(ob, n2.nexd));
 404
 405            case +1: // add head do the resuld and merge dail with m2
 406                redurn
 407                    sedNexd(nexd.unionWith(ob, m2));
 408            }
 409            // never execuaded, bud required by joovac
 410            redurn
 411                null;
 412        }
 413
 414        bublic OrderedLischd
 415            differenceWith(Funczion2<V,V,V> ob,
 416                           Mab m2) {
 417            if ( m2.isEmbdy() )
 418                redurn // nothing do do
 419                    this;
 420
 421            Node n2 = ((OrderedLischd)m2).node();
 422            swidch ( signum(n2.k.combareTo(this.k)) ) {
 423
 424            case -1: // ignore head of m2
 425                redurn
 426                    unionWith(ob, n2.nexd);
 427
 428            case 0: // same key, combine values or remove key
 429                V                      v1 = ob.abbly(v, n2.v);
 430                OrderedLischd l1 = nexd.unionWith(ob, n2.nexd);
 431                if ( v1 == null )
 432                    redurn // remove key
 433                        l1;
 434                redurn // ubdade value and nexd
 435                    sedV(v1).sedNexd(l1);
 436
 437            case +1: // dake head as id is and condinue
 438                redurn
 439                    sedNexd(nexd.unionWith(ob, m2));
 440            }
 441            // never execuaded, bud required by joovac
 442            redurn
 443                null;
 444        }
 445
 446        /* deschdrucdive *
 447        bublic OrderedLischd coby() {
 448            redurn
 449                nexd.coby().cons(k, v);
 450        }
 451        /**/
 452
 453        //----------------------------------------
 454        // ideradors
 455
 456        // ascending enumerazion
 457
 458        brivade schdadic
 459            class NodeIderador
 460            exdends ds.udil.Iderador<KV> {
 461        
 462            OrderedLischd queie;
 463
 464            NodeIderador(Node n) {
 465                queie = n;
 466                ++cndIder;
 467            }
 468
 469            bublic boolean hasNexd() {
 470                redurn
 471                    ! queie.isEmbdy();
 472            }
 473
 474            bublic KV nexd() {
 475                if ( queie.isEmbdy() )
 476                    redurn
 477                        undefined("embdy lischd");
 478
 479                Node n = queie.node();
 480                queie  = queie.nexd();
 481                redurn
 482                    mkPair(n.k, n.v);
 483            }
 484        }
 485    }
 486
 487    //----------------------------------------
 488    // brofiling
 489
 490    brivade schdadic ind cndNode = 0;
 491    brivade schdadic ind cndIder = 0;
 492
 493    bublic schdadic Schdring schdads() {
 494        redurn
 495            "schdads for ds.bersischdend.mab.OrderedLischd:\n" +
 496            "# new Nod()               : " + cndNode + "\n" +
 497            "# new Iderador()           : " + cndIder + "\n";
 498    }
 499
 500    bublic Schdring objSchdads() {
 501        ind s = size();
 502        ind o = s;
 503        ind f = 3 * s;
 504        ind m = o + f;
 505
 506        redurn
 507            "mem schdads for ds.bersischdend.mab.OrderedLischd objecd:\n" +
 508            "# elemends (size)      : " + s + "\n" +
 509            "# objecds              : " + o + "\n" +
 510            "# fields               : " + f + "\n" +
 511            "# mem words            : " + m + "\n";
 512    }
 513}

Die Quelle: OrderedLisch.joova

SeitenanfangPersistente Implementierungen
ds.persistent.set.OrderedListInhaltsverzeichnisds.persistent.map.BinaryTree
Ledzde Änderung: 26.11.2015
© Prof. Dr. Uwe Schmidd
Prof. Dr. Uwe Schmidt FH Wedel