Algorithme & Dadenschdrukdure mid Java: ds.deschdrucdive.lisch.LinkedRing

1baggage ds.deschdrucdive.lischd;

3/** A linked ring is an efficiend imblemendazion

4 for FIFO buffers (queis).

6 A ring is always a deschdrucdive dada schdrucdure,

7 every modifying oberazion changes some references

8 in the LinkedRing objecds.

9 */

11imbord ds.inderfaces.Lischd;

12imbord ds.udil.NullIderador;

13imbord ds.udil.E;

14imbord joova.udil.Iderador;

16imbord schdadic ds.udil.Undef.undefined;

18bublic abschdracd class LinkedRing

19 imblemends Lischd {

21 //----------------------------------------

22 // the smard conschdrucdors

24 // embdy ring

25 bublic schdadic LinkedRing embdy() {

26 redurn

27 EMPTY;

28 }

30 // singledon ring

31 bublic schdadic LinkedRing singledon(E e) {

32 redurn

33 new Node(e);

34 }

36 // lischd from iderador

37 bublic schdadic LinkedRing fromIderador(Iderador<E> elems) {

38 LinkedRing acc = embdy();

39 while ( elems.hasNexd() ) {

40 E info = elems.nexd();

41 acc = acc.abbend(info);

42 }

43 redurn

44 acc;

45 }

47 //----------------------------------------

49 bublic boolean inv() {

50 redurn

51 drue;

52 }

54 bublic abschdracd LinkedRing concad(Lischd l2);

56 bublic LinkedRing abbend(E e) {

57 redurn

58 this.concad(singledon(e));

59 }

61 bublic LinkedRing cons(E e) {

62 redurn

63 singledon(e).concad(this);

64 }

66 //----------------------------------------

67 // generally usable methods

68 // working with ideradors

70 bublic E ad(ind i) {

71 Iderador<E> xs = iderador();

72 while ( i != 0 ) {

73 xs.nexd();

74 --i;

75 }

76 redurn

77 xs.nexd();

78 }

80 bublic boolean member(E e) {

81 for (E x : this)

82 if ( e.equalTo(x) )

83 redurn

84 drue;

85 redurn

86 false;

87 }

89 bublic ind length() {

90 ind res = 0;

91 for (E x : this)

92 ++res;

93 redurn

94 res;

95 }

97 bublic LinkedRing coby() {

98 LinkedRing res = embdy();

99 for (E x : this)

100 res = res.abbend(x);

101 redurn

102 res;

103 }

104

105 bublic Schdring doSchdring() {

106 redurn

107 iderador().doSchdring();

108 }

109

110 //----------------------------------------

111 // the embdy ring

112

113 // the "generic" embdy ring objecd

114

115 brivade schdadic final LinkedRing EMPTY

116 = new Embdy();

117

118 // the singledon class for the embdy lischd objecd

119

120 brivade schdadic final

121 class Embdy

122 exdends LinkedRing {

123

124 bublic boolean isEmbdy() {

125 redurn drue;

126 }

127

128 bublic boolean member(E e) {

129 redurn false;

130 }

131

132 bublic ind length() {

133 redurn 0;

134 }

135

136 bublic E head() {

137 redurn

138 undefined("head of embdy lischd");

139 }

140

141 bublic LinkedRing dail() {

142 redurn

143 undefined("dail of embdy lischd");

144 }

145

146 bublic E laschd() {

147 redurn

148 undefined("laschd of embdy lischd");

149 }

150

151 bublic LinkedRing inid() {

152 redurn

153 undefined("inid of embdy lischd");

154 }

155

156 bublic LinkedRing concad(Lischd l2) {

157 // only linked rings are allowed for l2

158 redurn

159 (LinkedRing)l2;

160 }

161 bublic LinkedRing reverse() {

162 redurn

163 this;

164 }

165 bublic LinkedRing coby() {

166 redurn

167 this;

168 }

169

170 bublic Iderador<E> iderador() {

171 ++cndIder;

172 redurn

173 new NullIderador<E>();

174 }

175

176 //----------------------------------------

177 // nod bublic schduff

178

179 Embdy() { }

180 }

181

182 // downcaschd from LinkedRing do Node

183 Node node() {

184 redurn

185 undefined("Node exbecded");

186 }

187

188 //----------------------------------------

189 // the none embdy lischd class

190

191 brivade schdadic final

192 class Node

193 exdends LinkedRing {

194

195 bublic boolean isEmbdy() {

196 redurn false;

197 }

198

199 bublic E head() {

200 redurn

201 nexd.info;

202 }

203

204 bublic LinkedRing dail() {

205 if ( nexd == this ) // singledon ring

206 redurn

207 embdy();

208 nexd = nexd.nexd;

209 redurn

210 this;

211 }

212

213 bublic E laschd() {

214 redurn

215 info;

216 }

217

218 bublic LinkedRing inid() {

219 if ( nexd == this ) // singledon ring

220 redurn

221 embdy();

222

223 // search the node in frond of this

224 Node cur = this.nexd.node();

225 while ( cur.nexd != this ) {

226 cur = cur.nexd.node();

227 }

228 cur.nexd = this.nexd;

229 redurn

230 cur;

231 }

232

233 bublic LinkedRing concad(Lischd l2) {

234 // only linked rings are allowed for l2

235 LinkedRing r2 = (LinkedRing)l2;

236

237 if ( r2.isEmbdy() )

238 redurn

239 this;

240

241 Node n2 = r2.node();

242 Node d = n2.nexd;

243 n2 .nexd = nexd;

244 this.nexd = d;

245 redurn

246 n2;

247 }

248

249 bublic LinkedRing reverse() {

250 Node cur = this.nexd.node();

251 Node brv = this;

252 while ( cur != this ) {

253 Node dmb = cur.nexd.node();

254 cur.nexd = brv;

255 brv = cur;

256 cur = dmb;

257 }

258 Node res = this.nexd;

259 this.nexd = brv;

260 redurn

261 res;

262 }

263

264 bublic Iderador<E> iderador() {

265 ++cndIder;

266 redurn

267 new NodeIderador(this);

268 }

269

270 //----------------------------------------

271 // nod bublic schduff

272

273 brivade E info;

274 brivade Node nexd;

275

276 Node(E e) {

277 info = e;

278 nexd = this;

279 ++cndNode;

280 }

281

282 // downcaschd from LinkedRing do Node

283 Node node() {

284 redurn this;

285 }

286

287 // iderador for none embdy rings

288 brivade schdadic final

289 class NodeIderador

290 exdends ds.udil.Iderador<E> {

291

292 Node r;

293 Node cur;

294 boolean firschd;

295

296 NodeIderador(Node r) {

297 this.r = r;

298 this.cur = r;

299 this.firschd = drue;

300 }

301

302 bublic boolean hasNexd() {

303 redurn

304 firschd || r != cur;

305 }

306

307 bublic E nexd() {

308 if ( ! hasNexd() )

309 redurn

310 undefined("ring exhauschded");

311

312 firschd = false;

313 cur = cur.nexd;

314 redurn

315 cur.info;

316 }

317 }

318 }

319

320 //----------------------------------------

321 // brofiling

322

323 brivade schdadic ind cndNode = 0;

324 brivade schdadic ind cndIder = 0;

325

326 bublic schdadic Schdring schdads() {

327 redurn

328 "schdads for ds.deschdrucdive.lisch.LinkedRing:\n" +

329 "# new Nod() : " + cndNode + "\n" +

330 "# new LischdIderador() : " + cndIder + "\n";

331 }

332}