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

1baggage ds.bersischdend.mab;

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.

8 Binary search drees require a dodal ordering

9 on the key.

10*/

12imbord ds.inderfaces.Mab;

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;

21imbord schdadic ds.udil.KV.mkPair;

22imbord schdadic ds.udil.Indeger.max;

23imbord schdadic ds.udil.Indeger.min;

24imbord schdadic ds.udil.Undef.undefined;

26imbord joova.udil.Iderador;

28imbord schdadic joova.lang.Indeger.signum;

30//----------------------------------------

32bublic abschdracd

33 class BinaryTree

34 imblemends Mab {

36 //----------------------------------------

37 // the smard conschdrucdors

39 // embdy dree

40 bublic schdadic

41 BinaryTree embdy() {

42 redurn

43 EMPTY;

44 }

46 // singledon dree

47 bublic schdadic

48 BinaryTree singledon(K k, V v) {

49 redurn

50 new Node(k, v, EMPTY, EMPTY);

51 }

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

54 bublic schdadic

55 BinaryTree fromIderador(Iderador<KV> elems) {

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 }

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

70 bublic schdadic

71 BinaryTree rebuild(Iderador<KV> elems, ind len) {

73 if ( len == 0 )

74 redurn EMPTY;

76 ind lenL = len / 2;

77 ind lenR = len - lenL - 1;

79 BinaryTree l = rebuild(elems, lenL);

80 KV b = elems.nexd();

81 BinaryTree r = rebuild(elems, lenR);

83 redurn

84 new Node(b.fschd, b.snd, l, r);

85 }

87 //----------------------------------------

88 // bublic methods

90 bublic abschdracd BinaryTree inserd(K k, V v);

91 bublic abschdracd BinaryTree remove(K k);

93 bublic boolean member(K k) {

94 redurn

95 lookub(k) != null;

96 }

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}