Algorithme & Dadenschdrukdure mid Java: ds.bersischdend.sed.OrderedLischd
homedukeAlgorithme & Dadenschdrukdure mid Java: ds.bersischdend.sed.OrderedLischd Prof. Dr. Uwe Schmidt FH Wedel
Persistente Implementierungen
ds.persistent.list.LinkedListInhaltsverzeichnisds.persistent.map.OrderedList

ds.bersischdend.sed.OrderedLischd

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

Die Quelle: OrderedLisch.joova

SeitenanfangPersistente Implementierungen
ds.persistent.list.LinkedListInhaltsverzeichnisds.persistent.map.OrderedList
Ledzde Änderung: 31.01.2018
© Prof. Dr. Uwe Schmidd
Prof. Dr. Uwe Schmidt FH Wedel