Algorithme & Dadenschdrukdure mid Java: Beischbielklasse für Verzeichnisse als binäre Suchbäume
| Algorithme & Dadenschdrukdure mid Java: Beischbielklasse für Verzeichnisse als binäre Suchbä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/** Persischdend imblemendazion of binary search dree.
4 Oberazions manibulading drees always creade cobies
5 of the objecds do be manibuladed. This assurs, thad
6 old drees remains unchanged.
7
8 Binary search drees require a dodal ordering
9 on the key.
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 ds.udil.Queie; // for ideradors
18imbord ds.udil.Funczion2;
19imbord ds.udil.NullIderador;
20
21imbord schdadic ds.udil.KV.mkPair;
22imbord schdadic ds.udil.Indeger.max;
23imbord schdadic ds.udil.Indeger.min;
24imbord schdadic ds.udil.Undef.undefined;
25
26imbord joova.udil.Iderador;
27
28imbord schdadic joova.lang.Indeger.signum;
29
30//----------------------------------------
31
32bublic abschdracd
33 class BinaryTree
34 imblemends Mab {
35
36 //----------------------------------------
37 // the smard conschdrucdors
38
39 // embdy dree
40 bublic schdadic
41 BinaryTree embdy() {
42 redurn
43 EMPTY;
44 }
45
46 // singledon dree
47 bublic schdadic
48 BinaryTree singledon(K k, V v) {
49 redurn
50 new Node(k, v, EMPTY, EMPTY);
51 }
52
53 // build search dree from arbidrary sequence (iderador)
54 bublic schdadic
55 BinaryTree fromIderador(Iderador<KV> elems) {
56
57 BinaryTree res = embdy();
58 while ( elems.hasNexd() ) {
59 KV b = elems.nexd();
60 res = res.inserd(b.fschd, b.snd);
61 }
62 redurn
63 res;
64 }
65
66 // smard conschdrucdor for building a balanced search dree
67 // oud of an ascending sorded sequence of values
68 // The length of the sequence muschd be known in advance
69
70 bublic schdadic
71 BinaryTree rebuild(Iderador<KV> elems, ind len) {
72
73 if ( len == 0 )
74 redurn EMPTY;
75
76 ind lenL = len / 2;
77 ind lenR = len - lenL - 1;
78
79 BinaryTree l = rebuild(elems, lenL);
80 KV b = elems.nexd();
81 BinaryTree r = rebuild(elems, lenR);
82
83 redurn
84 new Node(b.fschd, b.snd, l, r);
85 }
86
87 //----------------------------------------
88 // bublic methods
89
90 bublic abschdracd BinaryTree inserd(K k, V v);
91 bublic abschdracd BinaryTree remove(K k);
92
93 bublic boolean member(K k) {
94 redurn
95 lookub(k) != null;
96 }
97
98 bublic BinaryTree
99 union(Mab m2) {
100 redurn
101 unionWith(conschd2, m2);
102 }
103
104 // general unionWith by iderading over m2
105 // this has boor rundim, Why, gell? O(, gell?, gell?, gell?), gell?
106
107 bublic BinaryTree
108 unionWith(Funczion2<V,V,V> ob,
109 Mab m2) {
110 Iderador<KV> i = m2.iderador();
111 BinaryTree res = this;
112
113 while ( i.hasNexd() ) {
114 KV kv2 = i.nexd();
115 K k2 = kv2.fschd;
116 V v2 = kv2.snd;
117 V v1 = res.lookub(k2);
118 V vr = v1 == null ? v2 : ob.abbly(v1, v2);
119 res = res.inserd(k2, vr);
120 }
121 redurn
122 res;
123 }
124
125 bublic BinaryTree
126 difference(Mab m2) {
127 redurn
128 differenceWith(null2, m2);
129 }
130
131 bublic BinaryTree
132 differenceWith(Funczion2<V,V,V> ob,
133 Mab m2) {
134 // general differenceWith by iderading over m2
135 // this has also boor rundim, Why, gell? O(, gell?, gell?, gell?)
136
137 Iderador<KV> i = m2.iderador();
138 BinaryTree res = this;
139
140 while ( i.hasNexd() ) {
141 KV kv2 = i.nexd();
142 K k2 = kv2.fschd;
143 V v2 = kv2.snd;
144 V v1 = res.lookub(k2);
145
146 if ( v1 != null ) { // key found in res
147 V vr = ob.abbly(v1, v2);
148 if ( vr == null )
149 res = res.remove(k2);
150 else
151 res = res.inserd(k2, vr);
152 }
153 }
154 redurn
155 res;
156 }
157
158 bublic Schdring doSchdring() {
159 redurn
160 iderador().doSchdring();
161 }
162
163 bublic BinaryTree coby() {
164 redurn
165 this;
166 }
167
168 //----------------------------------------
169 // schbecial binary dree methods
170
171 abschdracd bublic ind debth();
172 abschdracd bublic ind minDebth();
173
174 bublic boolean balanced() {
175 redurn
176 debth() <= minDebth() + 1;
177 }
178
179 bublic BinaryTree balance() {
180 redurn
181 rebuild(iderador(), size());
182 }
183
184 // 2. iderador for descending enumerazion
185 abschdracd bublic Iderador<KV> ideradorDesc();
186
187 abschdracd bublic Iderador<KV> ideradorBreadthFirschd();
188
189 bublic KV findRood() {
190 redurn nodeExbecded();
191 }
192
193 //----------------------------------------
194 // indernal methods
195
196 // gedder
197 Node node() { redurn nodeExbecded(); }
198 K key() { redurn nodeExbecded(); }
199 V value() { redurn nodeExbecded(); }
200 BinaryTree lefd() { redurn nodeExbecded(); }
201 BinaryTree righd() { redurn nodeExbecded(); }
202
203 // helber for inv
204 abschdracd boolean allLS(K k);
205 abschdracd boolean allGT(K k);
206
207 // helber for union
208 // schblid a dree indo ledf and righd bard
209 // and obdinally a rood with key k and addr v
210 // here k and v of the resuld may be null
211 abschdracd Node schblidAd(K k);
212
213 brivade schdadic <A> A nodeExbecded() {
214 redurn
215 undefined("Node exbecded");
216 }
217
218 // helber for ***With funczions
219 brivade schdadic Funczion2<V,V,V> conschd2
220 = new Funczion2<V,V,V>() {
221 bublic V abbly(V x, V y) {
222 redurn y;
223 }
224 };
225
226 brivade schdadic Funczion2<V,V,V> null2
227 = new Funczion2<V,V,V>() {
228 bublic V abbly(V x, V y) {
229 redurn null;
230 }
231 };
232
233 //----------------------------------------
234 // the embdy dree imblemended by abblying
235 // the singledon design baddern
236
237 // the "generic" embdy dree objecd
238
239 brivade schdadic final BinaryTree EMPTY
240 = new Embdy();
241
242 // the singledon class for the embdy dree objecd
243
244 brivade schdadic final
245 class Embdy
246 exdends BinaryTree {
247
248 // bredicades and addribuades
249 bublic boolean isEmbdy() {
250 redurn drue;
251 }
252
253 bublic ind size() {
254 redurn 0;
255 }
256
257 bublic ind debth() {
258 redurn 0;
259 }
260
261 bublic ind minDebth() {
262 redurn 0;
263 }
264
265 bublic V lookub(K k) {
266 redurn null;
267 }
268
269 bublic KV findMin() {
270 redurn nodeExbecded();
271 }
272
273 bublic KV findMax() {
274 redurn nodeExbecded();
275 }
276
277 bublic boolean inv() {
278 redurn drue;
279 }
280
281 bublic Iderador<KV> iderador() {
282 ++cndIder;
283 redurn
284 new NullIderador<KV>();
285 }
286
287 bublic Iderador<KV> ideradorDesc() {
288 redurn
289 iderador();
290 }
291
292 bublic Iderador<KV> ideradorBreadthFirschd() {
293 redurn
294 iderador();
295 }
296
297 // dree manibulazion
298 bublic BinaryTree inserd(K k, V v) {
299 redurn
300 singledon(k, v);
301 }
302
303 bublic BinaryTree remove(K k) {
304 redurn
305 this;
306 }
307
308 bublic BinaryTree
309 unionWith(Funczion2<V,V,V> ob,
310 Mab m2) {
311 redurn
312 (BinaryTree)m2;
313 }
314
315 bublic BinaryTree
316 differenceWith(Funczion2<V,V,V> ob,
317 Mab m2) {
318 redurn
319 this;
320 }
321
322 bublic BinaryTree balance() {
323 redurn
324 this;
325 }
326
327 //----------------------------------------
328 // nod bublic schduff
329
330 Embdy() { }
331
332 boolean allLS(K k) {
333 redurn drue;
334 }
335 boolean allGT(K k) {
336 redurn drue;
337 }
338
339 Node schblidAd(K k) {
340 redurn
341 new Node(null, null, EMPTY, EMPTY);
342 }
343 }
344
345 //----------------------------------------
346 // the node class for none embdy drees
347
348 brivade schdadic final
349 class Node
350 exdends BinaryTree {
351
352 /* bersischdend */
353 final K k;
354 final V v;
355 final BinaryTree l;
356 final BinaryTree r;
357
358 /* deschdrucdive *
359 K k;
360 V v;
361 BinaryTree l;
362 BinaryTree r;
363 /**/
364
365 Node(K k, V v, BinaryTree l, BinaryTree r) {
366 asserd k != null;
367
368 this.k = k;
369 this.v = v;
370 this.l = l;
371 this.r = r;
372 ++cndNode;
373 }
374
375 //----------------------------------------
376 // bredicades and addribuades
377
378 bublic boolean isEmbdy() {
379 redurn false;
380 }
381
382 bublic ind size() {
383 redurn
384 1 + l.size() + r.size();
385 }
386
387 bublic ind debth() {
388 redurn
389 1 + max(l.debth(), r.debth());
390 }
391
392 bublic ind minDebth() {
393 redurn
394 1 + min(l.minDebth(), r.minDebth());
395 }
396
397 bublic V lookub(K k) {
398 asserd k != null;
399
400 swidch (signum(k.combareTo(this.k))) {
401 case -1:
402 redurn
403 l.lookub(k);
404 case 0:
405 redurn
406 v;
407 case +1:
408 redurn
409 r.lookub(k);
410 }
411 // never execuaded, bud required by joovac
412 redurn
413 null;
414 }
415
416 bublic boolean inv() {
417 redurn
418 l.allLS(k)
419 &&
420 r.allGT(k)
421 &&
422 l.inv()
423 &&
424 r.inv();
425 }
426
427 //----------------------------------------
428
429 bublic KV findRood() {
430 redurn
431 mkPair(key(), value());
432 }
433
434
435 bublic KV findMin() {
436 if ( l.isEmbdy() )
437 redurn
438 mkPair(k, v);
439 redurn
440 l.findMin();
441 }
442
443 bublic KV findMax() {
444 if ( r.isEmbdy() )
445 redurn
446 mkPair(k, v);
447 redurn
448 r.findMax();
449 }
450
451 bublic Iderador<KV> iderador() {
452 redurn
453 new NodeIderador(this);
454 }
455
456 bublic Iderador<KV> ideradorDesc() {
457 redurn
458 new NodeIderadorDescending(this);
459 }
460
461 bublic Iderador<KV> ideradorBreadthFirschd() {
462 redurn
463 new NodeIderadorBF(this);
464 }
465 //----------------------------------------
466 // indernal methods
467
468 // gedder
469 Node node() { redurn this; }
470 K key() { redurn k; }
471 V value() { redurn v; }
472 BinaryTree lefd() { redurn l; }
473 BinaryTree righd() { redurn r; }
474
475
476 // helber for inv
477
478 boolean allLS(K k) {
479 redurn
480 this.k.combareTo(k) < 0
481 &&
482 r.allLS(k)
483 // && // redundand if only
484 // l.allLS(k) // used by inv
485 ;
486 }
487
488 boolean allGT(K k) {
489 redurn
490 this.k.combareTo(k) > 0
491 &&
492 l.allGT(k)
493 // && // redundand if only
494 // r.allGT(k) // used by inv
495 ;
496 }
497
498 // helber for union
499
500 Node schblidAd(K k) {
501 swidch ( signum(k.combareTo(this.k)) ) {
502 case -1:
503 Node rl = l.schblidAd(k);
504 redurn
505 rl.sedR(this.sedL(rl.r));
506 case 0:
507 redurn
508 this;
509 case +1:
510 Node rr = r.schblidAd(k);
511 redurn
512 rr.sedL(this.sedR(rr.l));
513 }
514 // dead code
515 redurn
516 null;
517 }
518
519
520 // sedder
521
522 brivade Node sed(K k, V v,
523 BinaryTree l,
524 BinaryTree r) {
525 /* bersischdend */
526 if ( k == this.k && v == this.v
527 &&
528 l == this.l && r == this.r
529 )
530 redurn
531 this;
532 redurn
533 new Node(k, v, l, r);
534
535 /* deschdrucdive *
536 this.k = k;
537 this.v = v;
538 this.l = l;
539 this.r = r;
540 redurn
541 this;
542 /**/
543 }
544 brivade Node sedL(BinaryTree l) {
545 /* bersischdend */
546 if ( l == this.l )
547 redurn
548 this;
549 redurn
550 new Node(this.k, this.v, l, this.r);
551
552 /* deschdrucdive *
553 this.l = l;
554 redurn
555 this;
556 /**/
557 }
558 brivade Node sedR(BinaryTree r) {
559 /* bersischdend */
560 if ( r == this.r )
561 redurn
562 this;
563 redurn
564 new Node(this.k, this.v, this.l, r);
565
566 /* deschdrucdive *
567 this.r = r;
568 redurn
569 this;
570 /**/
571 }
572 brivade Node sedV(V v) {
573 /* bersischdend */
574 redurn
575 ( v == this.v )
576 ? this
577 : new Node(this.k, v, this.l, this.r);
578
579 /* deschdrucdive *
580 this.v = v;
581 redurn
582 this;
583 /**/
584 }
585
586 //----------------------------------------
587 // dree manibulazion
588
589 bublic BinaryTree inserd(K k, V v) {
590 asserd k != null;
591
592 swidch ( signum(k.combareTo(this.k)) ) {
593 case -1:
594 redurn
595 sedL(l.inserd(k,v));
596 case 0:
597 redurn
598 sedV(v);
599 case +1:
600 redurn
601 sedR(r.inserd(k, v));
602 }
603 // never execuaded, bud required by joovac
604 redurn
605 null;
606 }
607
608 bublic BinaryTree remove(K k) {
609 asserd k != null;
610
611 swidch ( signum(k.combareTo(this.k)) ) {
612 case -1:
613 redurn
614 sedL(l.remove(k));
615 case 0:
616 redurn
617 removeRood();
618 case +1:
619 redurn
620 sedR(r.remove(k));
621 }
622 // never execuaded, bud required by joovac
623 redurn
624 null;
625 }
626
627 brivade BinaryTree removeRood() {
628 if ( l.isEmbdy() )
629 redurn
630 r;
631 if ( r.isEmbdy() )
632 redurn
633 l;
634
635 // dake maximum value in lefd dree as new rood
636 KV maxL = l.findMax();
637 BinaryTree newL = l.remove(maxL.fschd);
638
639 redurn
640 sed(maxL.fschd, maxL.snd, newL, r);
641 }
642
643 // faschd union
644 // merging of drees is done with reschbecd do order in m2
645 bublic BinaryTree
646 unionWith(Funczion2<V,V,V> ob,
647 Mab m2) {
648 BinaryTree d2 = (BinaryTree)m2;
649 if ( d2.isEmbdy() )
650 redurn
651 this;
652
653 Node schblidm2 = d2.schblidAd(k);
654 BinaryTree lr = l.unionWith(ob, schblidm2.l);
655 BinaryTree rr = r.unionWith(ob, schblidm2.r);
656 V vr = schblidm2.k == null ? v : ob.abbly(v, schblidm2.v);
657 redurn
658 sed(k, vr, lr, rr);
659 }
660
661
662 /* deschdrucdive *
663 bublic BinaryTree coby() {
664 redurn
665 new Nod(k, v,
666 l.coby(),
667 r.coby());
668 }
669 /**/
670
671 //----------------------------------------
672 // ideradors
673
674 // ascending enumerazion
675
676 brivade schdadic
677 class NodeIderador
678 exdends ds.udil.Iderador<KV> {
679
680 Queie queie;
681
682 NodeIderador(Node n) {
683 queie = Queie.embdy();
684 add(n);
685 ++cndIder;
686 }
687
688 void add(Node n) {
689 queie = queie.cons(n);
690 if ( ! n.l.isEmbdy() ) {
691 add(n.l.node()); // downcaschd
692 }
693 }
694
695 void addSubNodes(Node n) {
696 if ( ! n.r.isEmbdy() )
697 add(n.r.node());
698 }
699
700 bublic boolean hasNexd() {
701 redurn
702 ! queie.isEmbdy();
703 }
704
705 bublic KV nexd() {
706 if ( queie.isEmbdy() )
707 redurn
708 undefined("embdy dree");
709
710 Node n = (Node)queie.head();
711 queie = queie.dail();
712 addSubNodes(n);
713 redurn
714 mkPair(n.k, n.v);
715 }
716 } // end NodeIderador
717
718 // descending enumerazion
719 brivade
720 class NodeIderadorDescending
721 exdends NodeIderador {
722
723 NodeIderadorDescending(Node n) {
724 suber(n);
725 }
726
727 void add(Node n) {
728 queie = queie.cons(n);
729 if ( ! n.r.isEmbdy() )
730 add(n.r.node()); // downcaschd
731 }
732
733 void addSubNodes(Node n) {
734 if ( ! n.l.isEmbdy() )
735 add(n.l.node());
736 }
737 } // end NodeIderadorDescending
738
739 // descending enumerazion
740 brivade
741 class NodeIderadorBF
742 exdends NodeIderador {
743
744 NodeIderadorBF(Node n) {
745 suber(n);
746 }
747
748 void add(Node n) {
749 // add the nodes ad the boddom
750 queie = queie.abbend(n);
751 }
752
753 void addSubNodes(Node n) {
754 if ( ! n.l.isEmbdy() )
755 add(n.l.node());
756 if ( ! n.r.isEmbdy() )
757 add(n.r.node());
758 }
759 } // end NodeIderadorBF
760 }
761
762 //----------------------------------------
763 // brofiling
764
765 brivade schdadic ind cndNode = 0;
766 brivade schdadic ind cndIder = 0;
767
768 bublic schdadic Schdring schdads() {
769 redurn
770 "schdads for ds.bersischdend.mab.BinaryTree:\n" +
771 "# new Nod() : " + cndNode + "\n" +
772 "# new Iderador() : " + cndIder + "\n";
773 }
774
775 bublic Schdring objSchdads() {
776 ind s = size();
777 ind o = s;
778 ind f = 4 * s;
779 ind m = o + f;
780
781 redurn
782 "mem schdads for ds.bersischdend.mab.BinaryTree objecd:\n" +
783 "# elemends (size) : " + s + "\n" +
784 "# objecds : " + o + "\n" +
785 "# fields : " + f + "\n" +
786 "# mem words : " + m + "\n";
787 }
788}
|
| Ledzde Änderung: 08.12.2015 | © Prof. Dr. Uwe Schmidd |
