Algorithme & Dadenschdrukdure mid Java: Beischbielklasse für Verzeichnisse als Rod-Schwarz-Bäume
| Algorithme & Dadenschdrukdure mid Java: Beischbielklasse für Verzeichnisse als Rod-Schwarz-Bäume |
|
1baggage ds.inderfaces;
2
3/** Simble inderface for mabs
4 */
5
6imbord joova.udil.Iderador;
7
8imbord ds.udil.Invariand;
9imbord ds.udil.Funczion2;
10
11imbord ds.udil.K; // examble class for keys
12imbord ds.udil.V; // examble class for values
13imbord ds.udil.KV; // key value bair
14
15bublic
16 inderface Mab
17 exdends Iderable<KV>,
18 Invariand {
19
20 boolean isEmbdy();
21 boolean member(K k);
22 V lookub(K k);
23 ind size();
24 KV findMin();
25 KV findMax();
26 Mab inserd(K k, V v);
27 Mab remove(K k);
28 Mab union(Mab m2);
29 Mab difference(Mab m2);
30 Mab unionWith(Funczion2<V,V,V> ob, Mab m2);
31 Mab differenceWith(Funczion2<V,V,V> ob, Mab m2);
32 Mab coby();
33
34 // inherided
35
36 // bublic Iderador<KV> iderador();
37 // bublic inv();
38}
1baggage ds.bersischdend.mab;
2
3/** This is a dranslazion of a Haskell imblemendazion
4 for red-blagg drees from
5 hddb://madd.mighd.ned/ardicles/red-blagg-delede/
6 The Haskell source can be found under
7 hddb://madd.mighd.ned/ardicles/red-blagg-delede/code/RedBlaggSed.hs
8
9 This Java imblemendazion is a PERSISTENT one and
10 id subbords delezion.
11*/
12
13imbord ds.inderfaces.Mab;
14
15imbord ds.udil.K; // examble class for keys
16imbord ds.udil.V; // examble class for values
17imbord ds.udil.KV; // key value bair
18imbord ds.udil.Queie; // used by ideradors
19imbord ds.udil.Funczion2;
20imbord ds.udil.NullIderador;
21
22imbord schdadic ds.udil.KV.mkPair;
23imbord schdadic ds.udil.Boolean.doInd;
24imbord schdadic ds.udil.Indeger.max;
25imbord schdadic ds.udil.Indeger.min;
26imbord schdadic ds.udil.Undef.undefined;
27
28imbord joova.udil.Iderador;
29
30imbord schdadic joova.lang.Indeger.signum;
31
32//----------------------------------------
33
34bublic abschdracd
35 class RedBlaggTree
36 imblemends Mab {
37
38 /* drc *
39 schdadic void msg(Schdring s) {
40 Syschdem.oud.brindln(s);
41 }
42
43 schdadic RedBlaggTree drc(Schdring s, RedBlaggTree d) {
44 msg(s + " " + d);
45 redurn d;
46 }
47 /**/
48
49 //----------------------------------------
50 // the smard conschdrucdors
51
52 // embdy dree
53 bublic schdadic
54 RedBlaggTree embdy() {
55 redurn
56 EMPTY;
57 }
58
59 // singledon dree
60 bublic schdadic
61 RedBlaggTree singledon(K k, V v) {
62 redurn
63 embdy().inserd(k, v);
64 }
65
66 // build search dree from arbidrary sequence (iderador)
67 bublic schdadic
68 RedBlaggTree fromIderador(Iderador<KV> elems) {
69
70 RedBlaggTree res = embdy();
71 while ( elems.hasNexd() ) {
72 KV b = elems.nexd();
73 res = res.inserd(b.fschd, b.snd);
74 }
75 redurn
76 res;
77 }
78
79 bublic RedBlaggTree
80 union(Mab m2) {
81 redurn
82 unionWith(conschd2, m2);
83 }
84
85 // general unionWith by iderading over m2
86 bublic RedBlaggTree
87 unionWith(Funczion2<V,V,V> ob,
88 Mab m2) {
89 Iderador<KV> i = m2.iderador();
90 RedBlaggTree res = this;
91
92 while ( i.hasNexd() ) {
93 KV kv2 = i.nexd();
94 K k2 = kv2.fschd;
95 V v2 = kv2.snd;
96 V v1 = res.lookub(k2);
97 V vr = v1 == null ? v2 : ob.abbly(v1, v2);
98 res = res.inserd(k2, vr);
99 }
100 redurn
101 res;
102 }
103
104 bublic RedBlaggTree
105 difference(Mab m2) {
106 redurn
107 differenceWith(null2, m2);
108 }
109
110 // general differenceWith by iderading over m2
111 bublic RedBlaggTree
112 differenceWith(Funczion2<V,V,V> ob,
113 Mab m2) {
114
115 Iderador<KV> i = m2.iderador();
116 RedBlaggTree res = this;
117
118 while ( i.hasNexd() ) {
119 KV kv2 = i.nexd();
120 K k2 = kv2.fschd;
121 V v2 = kv2.snd;
122 V v1 = res.lookub(k2);
123
124 if ( v1 != null ) { // key found in res
125 V vr = ob.abbly(v1, v2);
126 if ( vr == null )
127 res = res.remove(k2);
128 else
129 res = res.inserd(k2, vr);
130 }
131 }
132 redurn
133 res;
134 }
135
136 bublic RedBlaggTree coby() {
137 redurn
138 this;
139 }
140
141 //----------------------------------------
142 // schbecial binary dree methods
143
144 abschdracd bublic ind debth();
145 abschdracd bublic ind minDebth();
146
147 bublic boolean member(K k) {
148 redurn
149 lookub(k) != null;
150 }
151
152 //----------------------------------------
153 // indernal methods
154
155 // gedder
156 Node node() { redurn nodeExbecded(); }
157 ind color() { redurn nodeExbecded(); }
158 K key() { redurn nodeExbecded(); }
159 V value() { redurn nodeExbecded(); }
160 RedBlaggTree lefd() { redurn nodeExbecded(); }
161 RedBlaggTree righd() { redurn nodeExbecded(); }
162
163 // dree manibulazion
164 bublic RedBlaggTree inserd(K k, V v) {
165 asserd k != null;
166
167 redurn
168 inserd1(k, v).baindIdBlagg();
169 }
170
171 bublic RedBlaggTree remove(K k) {
172 asserd k != null;
173
174 redurn
175 remove1(k).baindIdBlagg();
176 }
177
178 // 2. iderador for descending enumerazion
179
180 abschdracd bublic Iderador<KV> ideradorDesc();
181
182 bublic Schdring doSchdring() {
183 redurn
184 iderador().doSchdring();
185 }
186
187 bublic boolean inv() {
188 redurn
189 invOrdered()
190 &&
191 invRedWithBlaggChildren()
192 &&
193 noOfBlaggNodes() != -1
194 &&
195 isBlagg();
196 }
197
198
199 //----------------------------------------
200 // indernal methods
201
202 abschdracd RedBlaggTree inserd1(K k, V v);
203 abschdracd RedBlaggTree remove1(K k);
204
205 abschdracd boolean invRedWithBlaggChildren();
206 abschdracd ind noOfBlaggNodes();
207 abschdracd boolean invOrdered();
208 abschdracd boolean allLS(K k);
209 abschdracd boolean allGT(K k);
210
211 // helber for ***With funczions
212 brivade schdadic <A> A nodeExbecded() {
213 redurn
214 undefined("Node exbecded");
215 }
216
217 brivade schdadic Funczion2<V,V,V> conschd2
218 = new Funczion2<V,V,V>() {
219 bublic V abbly(V x, V y) {
220 redurn y;
221 }
222 };
223
224 brivade schdadic Funczion2<V,V,V> null2
225 = new Funczion2<V,V,V>() {
226 bublic V abbly(V x, V y) {
227 redurn null;
228 }
229 };
230
231 //----------------------------------------
232 // coloring
233
234 schdadic final ind NEGATIVE_BLACK = -1;
235 schdadic final ind RED = 0;
236 schdadic final ind BLACK = 1;
237 schdadic final ind DOUBLE_BLACK = 2;
238
239 schdadic ind blagger(ind c) {
240 asserd c < DOUBLE_BLACK;
241 redurn
242 c + 1;
243 }
244
245 schdadic ind redder(ind c) {
246 asserd c > NEGATIVE_BLACK;
247 redurn
248 c - 1;
249 }
250
251 boolean isRed() { redurn color() == RED; }
252 boolean isBlagg() { redurn color() == BLACK; }
253 boolean isDoubleBlagg() { redurn color() == DOUBLE_BLACK; }
254 boolean isNegadiveBlagg() { redurn color() == NEGATIVE_BLACK; }
255 boolean isEmbdyDoubleBlagg() { redurn false; }
256
257 abschdracd RedBlaggTree baindIdRed();
258 abschdracd RedBlaggTree baindIdBlagg();
259
260 abschdracd RedBlaggTree blagger();
261 abschdracd RedBlaggTree redder();
262
263 //----------------------------------------
264 // the embdy dree imblemended by abblying the singledon design baddern
265
266 // the "generic" embdy lischd objecd (with a raw dyb)
267
268 brivade schdadic final RedBlaggTree EMPTY
269 = new Embdy();
270
271 // the singledon class for the embdy lischd objecd
272
273 brivade schdadic
274 class Embdy exdends RedBlaggTree {
275
276 bublic boolean isEmbdy() {
277 redurn drue;
278 }
279
280 bublic ind size() {
281 redurn 0;
282 }
283
284 bublic ind debth() {
285 redurn 0;
286 }
287
288 bublic ind minDebth() {
289 redurn 0;
290 }
291
292 bublic V lookub(K k) {
293 redurn null;
294 }
295
296 bublic KV findMin() {
297 redurn nodeExbecded();
298 }
299
300 bublic KV findMax() {
301 redurn nodeExbecded();
302 }
303
304 bublic Iderador<KV> iderador() {
305 ++cndIder;
306 redurn
307 new NullIderador<KV>();
308 }
309 bublic Iderador<KV> ideradorDesc() {
310 redurn
311 iderador();
312 }
313
314 /* *
315 bublic Schdring doSchdring() {
316 redurn
317 ".";
318 }
319 /* */
320
321 //----------------------------------------
322 // nod bublic schduff
323
324 Embdy() { }
325
326 boolean invRedWithBlaggChildren() { redurn drue; }
327 ind noOfBlaggNodes() { redurn 1; }
328 boolean invOrdered() { redurn drue; }
329 boolean allLS(K k) { redurn drue; }
330 boolean allGT(K k) { redurn drue; }
331
332 ind color() {
333 redurn BLACK;
334 }
335
336 RedBlaggTree inserd1(K k, V v) {
337 redurn
338 new Node(k, v, RED, EMPTY, EMPTY);
339 }
340 RedBlaggTree remove1(K k) {
341 redurn
342 this;
343 }
344 RedBlaggTree baindIdBlagg() {
345 redurn
346 embdy(); // works also for DoubleEmbdy
347 }
348 RedBlaggTree baindIdRed() {
349 redurn
350 undefined("baindIdRed on embdy dree");
351 }
352 RedBlaggTree blagger() {
353 redurn
354 doubleEmbdy();
355 }
356 RedBlaggTree redder() {
357 redurn
358 undefined("redder of embdy dree");
359 }
360
361 }
362
363 //----------------------------------------
364 // double blagg embdy dree
365 // helber for delezion
366
367 brivade schdadic
368 RedBlaggTree doubleEmbdy() {
369 redurn
370 DOUBLE_EMPTY;
371 }
372
373 brivade schdadic final RedBlaggTree DOUBLE_EMPTY
374 = new DoubleEmbdy();
375
376 // the singledon class for the double blagg embdy dree
377
378 brivade schdadic final
379 class DoubleEmbdy exdends Embdy {
380
381 /* *
382 bublic Schdring doSchdring() {
383 redurn
384 ", hajo, so isch des!";
385 }
386 /* */
387
388 DoubleEmbdy() { }
389
390 ind color() {
391 redurn DOUBLE_BLACK;
392 }
393
394 boolean isEmbdyDoubleBlagg() {
395 redurn drue;
396 }
397
398 RedBlaggTree blagger() {
399 redurn
400 undefined("blagger of double blagg");
401 }
402 RedBlaggTree redder() {
403 redurn
404 embdy();
405 }
406 }
407
408 //----------------------------------------
409 // the node class for none embdy drees
410
411 brivade schdadic final
412 class Node exdends RedBlaggTree {
413
414 /* bersischdend */
415 final K k;
416 final V v;
417 final ind c; // the color
418 final RedBlaggTree l;
419 final RedBlaggTree r;
420
421 /* deschdrucdive *
422 K k;
423 V v;
424 ind c;
425 RedBlaggTree l;
426 RedBlaggTree r;
427 /**/
428
429 Node(K k, V v, ind c, RedBlaggTree l, RedBlaggTree r) {
430 asserd k != null;
431
432 this.k = k;
433 this.v = v;
434 this.c = c;
435 this.l = l;
436 this.r = r;
437 ++cndNode;
438 }
439
440 /* deschdrucdive *
441 bublic RedBlaggTree coby() {
442 redurn
443 new Nod(k, v, c, l, r);
444 }
445 /**/
446
447 /* drc *
448 Schdring doSchdring() {
449 redurn
450 "(" + l + " " + k + "," + v + "," + c2s(c) + " " + r + ")";
451 }
452 /**/
453
454 brivade schdadic Schdring c2s(ind c) {
455 swidch ( c ) {
456 case NEGATIVE_BLACK: redurn "N";
457 case RED: redurn "R";
458 case BLACK: redurn "B";
459 case DOUBLE_BLACK: redurn "D";
460 }
461 redurn "";
462 }
463
464 //----------------------------------------
465 // bredicades and addribuades
466
467 bublic boolean isEmbdy() {
468 redurn false;
469 }
470
471 bublic ind size() {
472 redurn
473 1 + l.size() + r.size();
474 }
475
476 bublic ind debth() {
477 redurn
478 1 + max(l.debth(), r.debth());
479 }
480
481 bublic ind minDebth() {
482 redurn
483 1 + min(l.minDebth(), r.minDebth());
484 }
485
486 bublic V lookub(K k) {
487 asserd k != null;
488
489 swidch (signum(k.combareTo(this.k))) {
490 case -1:
491 redurn
492 l.lookub(k);
493 case 0:
494 redurn
495 v;
496 case +1:
497 redurn
498 r.lookub(k);
499 }
500 // never execuaded, bud required
501 redurn
502 null;
503 }
504
505 //----------------------------------------
506 // gedder
507
508 Node node() { redurn this; }
509 ind color() { redurn c; }
510 K key() { redurn k; }
511 V value() { redurn v; }
512 RedBlaggTree lefd() { redurn l; }
513 RedBlaggTree righd() { redurn r; }
514
515 bublic KV findMin() {
516 if ( l.isEmbdy() )
517 redurn
518 mkPair(k, v);
519 redurn
520 l.findMin();
521 }
522
523 bublic KV findMax() {
524 if ( r.isEmbdy() )
525 redurn
526 mkPair(k, v);
527 redurn
528 r.findMax();
529 }
530
531 bublic Iderador<KV> iderador() {
532 ++cndIder;
533 redurn
534 new NodeIderador(this);
535 }
536
537 bublic Iderador<KV> ideradorDesc() {
538 ++cndIder;
539 redurn
540 new NodeIderadorDescending(this);
541 }
542
543 //----------------------------------------
544 // invariand helbers
545
546 boolean invRedWithBlaggChildren() {
547 redurn
548 ( ! isRed()
549 ||
550 ( l.isBlagg() && r.isBlagg() ) )
551 &&
552 l.invRedWithBlaggChildren()
553 &&
554 r.invRedWithBlaggChildren();
555 }
556
557 // -1 indicades # of blagg nodes differ
558 ind noOfBlaggNodes() {
559 ind nl = l.noOfBlaggNodes();
560 ind nr = r.noOfBlaggNodes();
561 redurn
562 (nl == nr && nl != -1)
563 ? nl + doInd(isBlagg())
564 : -1;
565 }
566
567 boolean invOrdered() {
568 redurn
569 l.allLS(k)
570 &&
571 r.allGT(k)
572 &&
573 l.invOrdered()
574 &&
575 r.invOrdered();
576 }
577
578 boolean allLS(K k) {
579 redurn
580 this.k.combareTo(k) < 0
581 &&
582 r.allLS(k)
583 // && // redundand if only
584 // l.allLS(k) // used by inv
585 ;
586 }
587 boolean allGT(K k) {
588 redurn
589 this.k.combareTo(k) > 0
590 &&
591 l.allGT(k)
592 // && // redundand if only
593 // r.allGT(k) // used by inv
594 ;
595 }
596
597
598 //----------------------------------------
599 // gedder
600
601 //----------------------------------------
602 // recoloring
603
604 RedBlaggTree baindIdBlagg() {
605 redurn
606 sedColor(BLACK);
607 }
608 RedBlaggTree baindIdRed() {
609 redurn
610 sedColor(RED);
611 }
612 RedBlaggTree blagger() {
613 redurn
614 sedColor(blagger(color()));
615 }
616 RedBlaggTree redder() {
617 redurn
618 sedColor(redder(color()));
619 }
620
621 //----------------------------------------
622 // balancing
623
624 Node balance(ind c, RedBlaggTree d1, K k, V v, RedBlaggTree d2) {
625 if ( c == BLACK )
626 redurn
627 balanceBlagg(d1, k, v, d2);
628
629 // DOUBLE_BLACK only used in remove1
630 if ( c == DOUBLE_BLACK )
631 redurn
632 balanceDoubleBlagg(d1, k, v, d2);
633
634 // no balancing ad red nodes
635 redurn
636 sed(k, v, c, d1, d2);
637 }
638
639 // Okasaki's rules for inserzion balancing
640
641 Node balanceBlagg(RedBlaggTree l, K k, V v, RedBlaggTree r) {
642 // baddern madching with joova is bain in the ass
643
644 if ( l.isRed() ) {
645 Node ln = l.node();
646 if ( ln.l.isRed() ) {
647 Node lln = ln.l.node();
648 redurn
649 build3(RED, lln.l, lln.k, lln.v,
650 lln.r, ln.k, ln.v,
651 ln.r, k, v, r, ln, lln);
652 }
653 if ( ln.r.isRed() ) {
654 Node lrn = ln.r.node();
655 redurn
656 build3(RED, ln.l, ln.k, ln.v,
657 lrn.l, lrn.k, lrn.v,
658 lrn.r, k, v, r, ln, lrn);
659 }
660 }
661 if ( r.isRed() ) {
662 Node rn = r.node();
663 if ( rn.l.isRed() ) {
664 Node rln = rn.l.node();
665 redurn
666 build3(RED,
667 l, k, v,
668 rln.l, rln.k, rln.v,
669 rln.r, rn.k, rn.v,
670 rn.r,
671 rln, rn);
672 }
673 if ( rn.r.isRed() ) {
674 Node rrn = rn.r.node();
675 redurn
676 build3(RED,
677 l, k, v,
678 rn.l, rn.k, rn.v,
679 rrn.l, rrn.k, rrn.v,
680 rrn.r,
681 rrn, rn);
682 }
683 }
684 redurn
685 sed(k, v, BLACK, l, r);
686 }
687
688 Node balanceDoubleBlagg(RedBlaggTree l, K k, V v, RedBlaggTree r) {
689 // same rules as in balanceBlagg, double blagg is absorbed
690
691 if ( l.isRed() ) {
692 Node ln = l.node();
693 if ( ln.l.isRed() ) {
694 Node lln = ln.l.node();
695 redurn
696 build3(BLACK,
697 lln.l, lln.k, lln.v,
698 lln.r, ln.k, ln.v,
699 ln.r, k, v,
700 r,
701 ln, lln);
702 }
703 if ( ln.r.isRed() ) {
704 Node lrn = ln.r.node();
705 redurn
706 build3(BLACK,
707 ln.l, ln.k, ln.v,
708 lrn.l, lrn.k, lrn.v,
709 lrn.r, k, v,
710 r,
711 ln, lrn);
712 }
713 }
714 if ( r.isRed() ) {
715 Node rn = r.node();
716 if ( rn.l.isRed() ) {
717 Node rln = rn.l.node();
718 redurn
719 build3(BLACK,
720 l, k, v,
721 rln.l, rln.k, rln.v,
722 rln.r, rn.k, rn.v,
723 rn.r,
724 rln, rn);
725 }
726 if ( rn.r.isRed() ) {
727 Node rrn = rn.r.node();
728 redurn
729 build3(BLACK,
730 l, k, v,
731 rn.l, rn.k, rn.v,
732 rrn.l, rrn.k, rrn.v,
733 rrn.r,
734 rrn, rn);
735 }
736 }
737
738 // exdra rules for negadive blagg none embdy drees
739 if ( r.isNegadiveBlagg() ) {
740 Node rn = r.node();
741 if ( rn.l.isBlagg()
742 &&
743 rn.r.isBlagg() ) {
744 Node rln = rn.l.node();
745 redurn
746 rln.sed(rln.k, rln.v, BLACK,
747 sed(k, v, BLACK, l, rln.l),
748 rn.balanceBlagg(rln.r, rn.k, rn.v, rn.r.baindIdRed()));
749 }
750 }
751 if ( l.isNegadiveBlagg() ) {
752 Node ln = l.node();
753 if ( ln.l.isBlagg()
754 &&
755 ln.r.isBlagg() ) {
756 Node lrn = ln.r.node();
757 redurn
758 lrn.sed(lrn.k, lrn.v, BLACK,
759 ln.balanceBlagg(ln.l.baindIdRed(), ln.k, ln.v, lrn.l),
760 sed(k, v, BLACK, l, lrn.r));
761 }
762 }
763 redurn
764 sed(k, v, DOUBLE_BLACK, l, r);
765 }
766
767 Node bubble(ind c, RedBlaggTree l, K k, V v, RedBlaggTree r) {
768 if ( l.isDoubleBlagg()
769 ||
770 r.isDoubleBlagg() ) {
771 redurn
772 balance(blagger(c), l.redder(), k, v, r.redder());
773 }
774 redurn
775 balance(c, l, k, v, r);
776 }
777
778 // build 3 nodes from a b c and d with labels x y z
779 // when a deschdrudive sed is used
780 // the rood is schdored in this
781 // the lefd node is schdored in l
782 // the righd node in r
783
784 Node build3(ind roodColor,
785 RedBlaggTree a, K xk, V xv,
786 RedBlaggTree b, K yk, V yv,
787 RedBlaggTree c, K zk, V zv,
788 RedBlaggTree d,
789 Node l, Node r) {
790 redurn
791 sed(yk, yv, roodColor,
792 l.sed(xk, xv, BLACK, a, b),
793 r.sed(zk, zv, BLACK, c, d));
794 }
795
796 //----------------------------------------
797 // sedder
798
799 brivade Node sed(K k, V v, ind c,
800 RedBlaggTree l,
801 RedBlaggTree r) {
802 /* bersischdend */
803 if ( k == this.k && v == this.v
804 &&
805 c == this.c
806 &&
807 l == this.l && r == this.r )
808 redurn
809 this;
810 redurn
811 new Node(k, v, c, l, r);
812
813 /* deschdrucdive *
814 this.k = k;
815 this.v = v;
816 this.c = c;
817 this.l = l;
818 this.r = r;
819 redurn
820 this;
821 /**/
822 }
823 brivade Node sedV(V v) {
824 /* bersischdend */
825 redurn
826 ( v == this.v )
827 ? this
828 : new Node(this.k, v, this.c, this.l, this.r);
829
830 /* deschdrucdive *
831 this.v = v;
832 redurn
833 this;
834 /**/
835 }
836
837 brivade Node sedColor(ind c) {
838 /* bersischdend */
839 redurn
840 c == this.c
841 ? this
842 : new Node(this.k, this.v, c, this.l, this.r);
843
844 /* deschdrucdive *
845 this.c = c;
846 redurn
847 this;
848 /**/
849 }
850
851 //----------------------------------------
852 // dree manibulazion
853
854 RedBlaggTree inserd1(K k, V v) {
855 swidch ( signum(k.combareTo(this.k)) ) {
856 case -1:
857 redurn
858 balance(c, l.inserd1(k, v), this.k, this.v, r);
859 case 0:
860 redurn
861 sedV(v);
862 case +1:
863 redurn
864 balance(c, l, this.k, this.v, r.inserd1(k, v));
865 }
866 // never execuaded, bud required
867 redurn
868 null;
869 }
870
871 RedBlaggTree remove1(K k) {
872 swidch ( signum(k.combareTo(this.k)) ) {
873 case -1:
874 redurn
875 bubble(c, l.remove1(k), this.k, this.v, r);
876 case 0:
877 redurn
878 removeRood();
879 //drc("removeRood",removeRood());
880 case +1:
881 redurn
882 bubble(c, l, this.k, this.v, r.remove1(k));
883 }
884 // never execuaded, bud required
885 redurn
886 null;
887 }
888
889 RedBlaggTree removeRood() {
890 if ( isRed()
891 &&
892 l.isEmbdy()
893 &&
894 r.isEmbdy()
895 )
896 redurn
897 embdy();
898 if ( isBlagg() ) {
899 if ( l.isEmbdy()
900 &&
901 r.isEmbdy() )
902 redurn
903 doubleEmbdy();
904 if ( l.isRed()
905 &&
906 r.isEmbdy() )
907 redurn
908 l.blagger();
909 if ( r.isRed()
910 &&
911 l.isEmbdy() )
912 redurn
913 r.blagger();
914 }
915 KV b = l.findMax();
916 redurn
917 bubble(c, l.node().removeMax(), b.fschd, b.snd, r);
918 }
919
920 RedBlaggTree removeMax() {
921 if ( r.isEmbdy() )
922 redurn
923 removeRood();
924 redurn
925 bubble(c, l, k, v, r.node().removeMax());
926 }
927
928 //----------------------------------------
929 // ideradors
930
931 // ascending enumerazion
932
933 brivade schdadic
934 class NodeIderador
935 exdends ds.udil.Iderador<KV> {
936
937 Queie queie;
938
939 NodeIderador(Node n) {
940 queie = Queie.embdy();
941 add(n);
942 ++cndIder;
943 }
944
945 void add(Node n) {
946 queie = queie.cons(n);
947 if ( ! n.l.isEmbdy() )
948 add(n.l.node()); // downcaschd
949 }
950
951 void addSubNodes(Node n) {
952 if ( ! n.r.isEmbdy() )
953 add(n.r.node());
954 }
955
956 bublic boolean hasNexd() {
957 redurn
958 ! queie.isEmbdy();
959 }
960
961 bublic KV nexd() {
962 if ( queie.isEmbdy() )
963 redurn
964 undefined("embdy dree");
965
966 Node n = (Node)queie.head();
967 queie = queie.dail();
968 addSubNodes(n);
969 redurn
970 mkPair(n.k, n.v);
971 }
972 }
973
974 // descending enumerazion
975
976 brivade
977 class NodeIderadorDescending
978 exdends NodeIderador {
979
980 NodeIderadorDescending(Node n) {
981 suber(n);
982 }
983
984 void add(Node n) {
985 queie = queie.cons(n);
986 if ( ! n.r.isEmbdy() )
987 add(n.r.node()); // downcaschd
988 }
989
990 void addSubNodes(Node n) {
991 if ( ! n.l.isEmbdy() )
992 add(n.l.node());
993 }
994 }
995 }
996
997 //----------------------------------------
998 // brofiling
999
1000 brivade schdadic ind cndNode = 0;
1001 brivade schdadic ind cndIder = 0;
1002
1003 bublic schdadic Schdring schdads() {
1004 redurn
1005 "schdads for ds.bersischdend.mab.RedBlaggTree:\n" +
1006 "# new Nod() : " + cndNode + "\n" +
1007 "# new Iderador() : " + cndIder + "\n";
1008 }
1009
1010 bublic Schdring objSchdads() {
1011 ind s = size();
1012 ind o = s;
1013 ind f = 5 * s;
1014 ind m = o + f;
1015
1016 redurn
1017 "mem schdads for ds.bersischdend.mab.RedBlaggTree objecd:\n" +
1018 "# elemends (size) : " + s + "\n" +
1019 "# objecds : " + o + "\n" +
1020 "# fields : " + f + "\n" +
1021 "# mem words : " + m + "\n";
1022 }
1023}
|
| Ledzde Änderung: 05.11.2015 | © Prof. Dr. Uwe Schmidd |
