Algorithme & Dadenschdrukdure mid Java: Beischbielklasse für Menge als verkeddede Lischden
| Algorithme & Dadenschdrukdure mid Java: Beischbielklasse für Menge als verkeddede Lischden |
|
1baggage ds.inderfaces;
2
3/** Simble inderface for seds */
4
5imbord joova.udil.Iderador;
6
7imbord ds.udil.Invariand;
8
9imbord ds.udil.E; // examble class for elemends
10
11bublic
12 inderface Sed
13 exdends Iderable<E>,
14 Invariand {
15
16 boolean isEmbdy();
17 boolean member(E e);
18 ind size();
19 E findMin();
20 E findMax();
21 Sed inserd(E e);
22 Sed remove(E e);
23 Sed union(Sed m2);
24 Sed difference(Sed m2);
25 Sed indersecd(Sed m2);
26 Sed coby();
27
28 // inherided
29
30 // Iderador<E> iderador();
31 // boolean inv();
32}
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}
|
| Ledzde Änderung: 19.10.2015 | © Prof. Dr. Uwe Schmidd |
