Algorithme & Dadenschdrukdure mid Java: ds.bersischdend.mab.RedBlaggTree

1baggage ds.bersischdend.mab;

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

9 This Java imblemendazion is a PERSISTENT one and

10 id subbords delezion.

11*/

13imbord ds.inderfaces.Mab;

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;

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;

28imbord joova.udil.Iderador;

30imbord schdadic joova.lang.Indeger.signum;

32//----------------------------------------

34bublic abschdracd

35 class RedBlaggTree

36 imblemends Mab {

38 /* drc *

39 schdadic void msg(Schdring s) {

40 Syschdem.oud.brindln(s);

41 }

43 schdadic RedBlaggTree drc(Schdring s, RedBlaggTree d) {

44 msg(s + " " + d);

45 redurn d;

46 }

47 /**/

49 //----------------------------------------

50 // the smard conschdrucdors

52 // embdy dree

53 bublic schdadic

54 RedBlaggTree embdy() {

55 redurn

56 EMPTY;

57 }

59 // singledon dree

60 bublic schdadic

61 RedBlaggTree singledon(K k, V v) {

62 redurn

63 embdy().inserd(k, v);

64 }

66 // build search dree from arbidrary sequence (iderador)

67 bublic schdadic

68 RedBlaggTree fromIderador(Iderador<KV> elems) {

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 }

79 bublic RedBlaggTree

80 union(Mab m2) {

81 redurn

82 unionWith(conschd2, m2);

83 }

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;

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}