API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 25th, 2016
96
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 17.00 KB | None | 0 0
raw download clone embed print report
  1. /* File : listdp.h */
  2. /* ADT List dengan Double Pointer */
  3. /* Representasi berkait dengan address adalah pointer */
  4. /* infotype adalah integer */
  5.  
  6. /*
  7. NIM : 13515028
  8. Nama : Taufan Mahaputra
  9. Tanggal : 24 Oktober 2016
  10. Topik praktikum : List Sirkuler
  11. Deskripsi : Implementasi list sirkuler
  12. */
  13.  
  14. #include "listdp.h"
  15. #include "boolean.h"
  16. #include <stdlib.h>
  17. #include <stdio.h>
  18.  
  19. #define Nil NULL
  20.  
  21.  
  22. /* Definisi list : */
  23. /* List kosong : First(L) = Nil dan Last(L) = Nil */
  24. /* Setiap elemen dengan address P dapat diacu Info(P), Next(P), Prev(P) */
  25. /* Elemen terakhir list: Last(L) */
  26.  
  27. /* Notasi Akses */
  28. #define Info(P) (P)->info
  29. #define Next(P) (P)->next
  30. #define Prev(P) (P)->prev
  31. #define First(L) ((L).First)
  32. #define Last(L) ((L).Last)
  33.  
  34. /* PROTOTYPE */
  35. /****************** TEST LIST KOSONG ******************/
  36. boolean IsEmpty (List L)
  37. /* Mengirim true jika list kosong. Lihat definisi di atas. */
  38. {
  39. return (First(L) == Nil) && (Last(L) == Nil);
  40. }
  41. /****************** PEMBUATAN LIST KOSONG ******************/
  42. void CreateEmpty (List *L)
  43. /* I.S. L sembarang */
  44. /* F.S. Terbentuk list kosong. Lihat definisi di atas. */
  45. {
  46. First(*L) = Nil;
  47. Last(*L) = Nil;
  48. }
  49. /****************** Manajemen Memori ******************/
  50. address Alokasi (infotype X)
  51. /* Mengirimkan address hasil alokasi sebuah elemen */
  52. /* Jika alokasi berhasil, maka address tidak nil. */
  53. /* Misalnya: menghasilkan P, maka Info(P)=X, Next(P)=Nil, Prev(P)=Nil */
  54. /* Jika alokasi gagal, mengirimkan Nil. */
  55. {
  56. address P;
  57.  
  58. /* Algoritma */
  59. P = (address) malloc (sizeof (ElmtList));
  60. if (P != Nil) {
  61. Info(P) = X;
  62. Next(P) = Nil;
  63. Prev(P) = Nil;
  64. return P;
  65. } else {
  66. return Nil;
  67. }
  68. }
  69. void Dealokasi (address P)
  70. /* I.S. P terdefinisi */
  71. /* F.S. P dikembalikan ke sistem */
  72. /* Melakukan dealokasi/pengembalian address P */
  73. {
  74. free(P);
  75. }
  76. /****************** PENCARIAN SEBUAH ELEMEN LIST ******************/
  77. address Search (List L, infotype X)
  78. /* Mencari apakah ada elemen list dengan Info(P)=X */
  79. /* Jika ada, mengirimkan address elemen tersebut. */
  80. /* Jika tidak ada, mengirimkan Nil */
  81. {
  82. address P = First(L);
  83. boolean found = false;
  84.  
  85. while ((P != Nil) && !found)
  86. {
  87. if(Info(P) == X)
  88. {
  89. found = true;
  90. }
  91. else
  92. {
  93. P = Next(P);
  94. }
  95. }
  96. return P;
  97. }
  98.  
  99. /****************** PRIMITIF BERDASARKAN NILAI ******************/
  100. /*** PENAMBAHAN ELEMEN ***/
  101. void InsVFirst (List *L, infotype X)
  102. /* I.S. L mungkin kosong */
  103. /* F.S. Melakukan alokasi sebuah elemen dan */
  104. /* menambahkan elemen pertama dengan nilai X jika alokasi berhasil */
  105. {
  106. address P;
  107.  
  108. P = Alokasi(X);
  109. if (P != Nil)
  110. {
  111. InsertFirst(L,P);
  112. }
  113. }
  114. void InsVLast (List *L, infotype X)
  115. /* I.S. L mungkin kosong */
  116. /* F.S. Melakukan alokasi sebuah elemen dan */
  117. /* menambahkan elemen list di akhir: elemen terakhir yang baru */
  118. /* bernilai X jika alokasi berhasil. Jika alokasi gagal: I.S.= F.S. */
  119. {
  120. address P;
  121.  
  122. P = Alokasi(X);
  123. if (P != Nil)
  124. {
  125. InsertLast(L,P);
  126. }
  127. }
  128. /*** PENGHAPUSAN ELEMEN ***/
  129. void DelVFirst (List *L, infotype *X)
  130. /* I.S. List L tidak kosong */
  131. /* F.S. Elemen pertama list dihapus: nilai info disimpan pada X */
  132. /* dan alamat elemen pertama di-dealokasi */
  133. {
  134. address P;
  135.  
  136. DelFirst(L,&P);
  137. (*X) = Info(P);
  138. Dealokasi(P);
  139. }
  140. void DelVLast (List *L, infotype *X)
  141. /* I.S. list tidak kosong */
  142. /* F.S. Elemen terakhir list dihapus: nilai info disimpan pada X */
  143. /* dan alamat elemen terakhir di-dealokasi */
  144. {
  145. {
  146. address P;
  147.  
  148. DelLast(L,&P);
  149. (*X) = Info(P);
  150. Dealokasi(P);
  151. }
  152. }
  153. /****************** PRIMITIF BERDASARKAN ALAMAT ******************/
  154. /*** PENAMBAHAN ELEMEN BERDASARKAN ALAMAT ***/
  155. void InsertFirst (List *L, address P)
  156. /* I.S. Sembarang, P sudah dialokasi */
  157. /* F.S. Menambahkan elemen ber-address P sebagai elemen pertama */
  158. {
  159. if(IsEmpty(*L))
  160. {
  161. Last(*L) = P;
  162. }
  163. else
  164. {
  165. Next(P) = First(*L);
  166. Prev(First(*L)) = P;
  167. }
  168.  
  169. First(*L) = P;
  170. }
  171. void InsertLast (List *L, address P)
  172. /* I.S. Sembarang, P sudah dialokasi */
  173. /* F.S. P ditambahkan sebagai elemen terakhir yang baru */
  174. {
  175.  
  176. if(IsEmpty(*L))
  177. {
  178. InsertFirst(L,P);
  179. }
  180. else
  181. {
  182. Prev(P) = Last(*L);
  183. Next(Last(*L)) = P;
  184. Last(*L) = P;
  185. }
  186. }
  187. void InsertAfter (List *L, address P, address Prec)
  188. /* I.S. Prec pastilah elemen list; P sudah dialokasi */
  189. /* F.S. Insert P sebagai elemen sesudah elemen beralamat Prec */
  190. {
  191. if(Last(*L) == Prec)
  192. {
  193. InsertLast(L, P);
  194. }
  195. else
  196. {
  197. Next(P) = Next(Prec);
  198. Prev(Next(Prec)) = P;
  199. Next(Prec) = P;
  200. Prev(P) = Prec;
  201. }
  202.  
  203.  
  204. }
  205. void InsertBefore (List *L, address P, address Succ)
  206. /* I.S. Succ pastilah elemen list; P sudah dialokasi */
  207. /* F.S. Insert P sebagai elemen sebelum elemen beralamat Succ */
  208. {
  209. if(First(*L) == Succ)
  210. {
  211. InsertFirst(L,P);
  212. }
  213. else
  214. {
  215. Prev(P) = Prev(Succ);
  216. Next(Prev(Succ)) = P;
  217. Next(P) = Succ;
  218. Prev(Succ) = P;
  219. }
  220. }
  221. /*** PENGHAPUSAN SEBUAH ELEMEN ***/
  222. void DelFirst (List *L, address *P)
  223. /* I.S. List tidak kosong */
  224. /* F.S. P adalah alamat elemen pertama list sebelum penghapusan */
  225. /* Elemen list berkurang satu (mungkin menjadi kosong) */
  226. /* First element yg baru adalah suksesor elemen pertama yang lama */
  227. {
  228. *P = First(*L);
  229. First(*L) = Next(*P);
  230. if(First(*L) == Nil)
  231. {
  232. Last(*L) = Nil;
  233. }
  234. else
  235. {
  236. Prev(First(*L)) = Nil;
  237. }
  238.  
  239. Next(*P)=Nil;
  240. }
  241. void DelLast (List *L, address *P)
  242. /* I.S. List tidak kosong */
  243. /* F.S. P adalah alamat elemen terakhir list sebelum penghapusan */
  244. /* Elemen list berkurang satu (mungkin menjadi kosong) */
  245. /* Last element baru adalah predesesor elemen pertama yg lama, jika ada */
  246. {
  247. *P = Last(*L);
  248. Last(*L) = Prev(*P);
  249. if(Last(*L) == Nil)
  250. {
  251. First(*L) = Nil;
  252. }
  253. else
  254. {
  255. Next(Last(*L)) = Nil;
  256. }
  257.  
  258. Next(*P)=Nil;
  259. }
  260. void DelP (List *L, infotype X)
  261. /* I.S. Sembarang */
  262. /* F.S. Jika ada elemen list beraddress P, dengan Info(P)=X */
  263. /* maka P dihapus dari list dan didealokasi */
  264. /* Jika tidak ada elemen list dengan Info(P)=X, maka list tetap */
  265. /* List mungkin menjadi kosong karena penghapusan */
  266. {
  267. if(!IsEmpty(*L))
  268. {
  269. address P = Search(*L,X);
  270. if(P!=Nil)
  271. {
  272. if(P == First(*L))
  273. {
  274. DelFirst(L,&P);
  275. }
  276. else
  277. {
  278. address Prev = First(*L);
  279. while(Next(Prev) != P)
  280. {
  281. Prev = Next(Prev);
  282. }
  283. DelAfter(L,&P,Prev);
  284. }
  285. Dealokasi(P);
  286. }
  287. }
  288. }
  289. void DelAfter (List *L, address *Pdel, address Prec)
  290. /* I.S. List tidak kosong. Prec adalah anggota list. */
  291. /* F.S. Menghapus Next(Prec): */
  292. /* Pdel adalah alamat elemen list yang dihapus */
  293. {
  294. if (Last(*L) == Next(Prec)){
  295. DelLast(L,Pdel);
  296. }
  297. else if (Next(Prec) != Nil)
  298. {
  299. *Pdel = Next(Prec);
  300. Next(Prec) = Next(*Pdel);
  301. Prev(Next(*Pdel)) = Prec;
  302. Prev(*Pdel) = Nil;
  303. Next(*Pdel) = Nil;
  304. }
  305. }
  306. void DelBefore (List *L, address *Pdel, address Succ)
  307. /* I.S. List tidak kosong. Succ adalah anggota list. */
  308. /* F.S. Menghapus Prev(Succ): */
  309. /* Pdel adalah alamat elemen list yang dihapus */
  310. {
  311. if(First(*L) == Prev(Succ)){
  312. DelFirst(L, Pdel);
  313. }
  314. else if(Prev(Succ) !=Nil)
  315. {
  316. *Pdel = Prev(Succ);
  317. Next(Prev(*Pdel)) = Succ;
  318. Prev(Succ) = Prev(*Pdel);
  319. Next(*Pdel) = Nil;
  320. Prev(*Pdel) = Nil;
  321. }
  322. }
  323. /****************** PROSES SEMUA ELEMEN LIST ******************/
  324. void PrintForward (List L)
  325. /* I.S. List mungkin kosong */
  326. /* F.S. Jika list tidak kosong, isi list dicetak dari elemen pertama */
  327. /* ke elemen terakhir secara horizontal ke kanan: [e1,e2,...,en] */
  328. /* Contoh : jika ada tiga elemen bernilai 1, 20, 30 akan dicetak: [1,20,30] */
  329. /* Jika list kosong : menulis [] */
  330. /* Tidak ada tambahan karakter apa pun di awal, akhir, atau di tengah */
  331. {
  332. if(IsEmpty(L))
  333. {
  334. printf("[]");
  335. }
  336. else
  337. {
  338. address P = First(L);
  339.  
  340. printf("[");
  341. while(P != Nil)
  342. {
  343. printf("%d", Info(P));
  344. if(Next(P) != Nil)
  345. {
  346. printf(",");
  347. }
  348. P=Next(P);
  349. }
  350. printf("]");
  351. }
  352. }
  353. void PrintBackward (List L)
  354. /* I.S. List mungkin kosong */
  355. /* F.S. Jika list tidak kosong, isi list dicetak dari elemen terakhir */
  356. /* ke elemen pertama secara horizontal ke kanan: [en,en-1,...,e2,e1] */
  357. /* Contoh : jika ada tiga elemen bernilai 1, 20, 30 akan dicetak: [30,20,1] */
  358. /* Jika list kosong : menulis [] */
  359. /* Tidak ada tambahan karakter apa pun di awal, akhir, atau di tengah */
  360. {
  361. if(IsEmpty(L))
  362. {
  363. printf("[]");
  364. }
  365. else
  366. {
  367. address P = Last(L);
  368.  
  369. printf("[");
  370. while(P != Nil)
  371. {
  372. printf("%d", Info(P));
  373. if(Prev(P) != Nil)
  374. {
  375. printf(",");
  376. }
  377. P=Prev(P);
  378. }
  379. printf("]");
  380. }
  381. }
  382. /* File : listdp.h */
  383. /* ADT List dengan Double Pointer */
  384. /* Representasi berkait dengan address adalah pointer */
  385. /* infotype adalah integer */
  386.  
  387. /*
  388. NIM : 13515028
  389. Nama : Taufan Mahaputra
  390. Tanggal : 24 Oktober 2016
  391. Topik praktikum : List Sirkuler
  392. Deskripsi : Implementasi list sirkuler
  393. */
  394.  
  395. #include "listdp.h"
  396. #include "boolean.h"
  397. #include <stdlib.h>
  398. #include <stdio.h>
  399.  
  400. #define Nil NULL
  401.  
  402.  
  403. /* Definisi list : */
  404. /* List kosong : First(L) = Nil dan Last(L) = Nil */
  405. /* Setiap elemen dengan address P dapat diacu Info(P), Next(P), Prev(P) */
  406. /* Elemen terakhir list: Last(L) */
  407.  
  408. /* Notasi Akses */
  409. #define Info(P) (P)->info
  410. #define Next(P) (P)->next
  411. #define Prev(P) (P)->prev
  412. #define First(L) ((L).First)
  413. #define Last(L) ((L).Last)
  414.  
  415. /* PROTOTYPE */
  416. /****************** TEST LIST KOSONG ******************/
  417. boolean IsEmpty (List L)
  418. /* Mengirim true jika list kosong. Lihat definisi di atas. */
  419. {
  420. return (First(L) == Nil) && (Last(L) == Nil);
  421. }
  422. /****************** PEMBUATAN LIST KOSONG ******************/
  423. void CreateEmpty (List *L)
  424. /* I.S. L sembarang */
  425. /* F.S. Terbentuk list kosong. Lihat definisi di atas. */
  426. {
  427. First(*L) = Nil;
  428. Last(*L) = Nil;
  429. }
  430. /****************** Manajemen Memori ******************/
  431. address Alokasi (infotype X)
  432. /* Mengirimkan address hasil alokasi sebuah elemen */
  433. /* Jika alokasi berhasil, maka address tidak nil. */
  434. /* Misalnya: menghasilkan P, maka Info(P)=X, Next(P)=Nil, Prev(P)=Nil */
  435. /* Jika alokasi gagal, mengirimkan Nil. */
  436. {
  437. address P;
  438.  
  439. /* Algoritma */
  440. P = (address) malloc (sizeof (ElmtList));
  441. if (P != Nil) {
  442. Info(P) = X;
  443. Next(P) = Nil;
  444. Prev(P) = Nil;
  445. return P;
  446. } else {
  447. return Nil;
  448. }
  449. }
  450. void Dealokasi (address P)
  451. /* I.S. P terdefinisi */
  452. /* F.S. P dikembalikan ke sistem */
  453. /* Melakukan dealokasi/pengembalian address P */
  454. {
  455. free(P);
  456. }
  457. /****************** PENCARIAN SEBUAH ELEMEN LIST ******************/
  458. address Search (List L, infotype X)
  459. /* Mencari apakah ada elemen list dengan Info(P)=X */
  460. /* Jika ada, mengirimkan address elemen tersebut. */
  461. /* Jika tidak ada, mengirimkan Nil */
  462. {
  463. address P = First(L);
  464. boolean found = false;
  465.  
  466. while ((P != Nil) && !found)
  467. {
  468. if(Info(P) == X)
  469. {
  470. found = true;
  471. }
  472. else
  473. {
  474. P = Next(P);
  475. }
  476. }
  477. return P;
  478. }
  479.  
  480. /****************** PRIMITIF BERDASARKAN NILAI ******************/
  481. /*** PENAMBAHAN ELEMEN ***/
  482. void InsVFirst (List *L, infotype X)
  483. /* I.S. L mungkin kosong */
  484. /* F.S. Melakukan alokasi sebuah elemen dan */
  485. /* menambahkan elemen pertama dengan nilai X jika alokasi berhasil */
  486. {
  487. address P;
  488.  
  489. P = Alokasi(X);
  490. if (P != Nil)
  491. {
  492. InsertFirst(L,P);
  493. }
  494. }
  495. void InsVLast (List *L, infotype X)
  496. /* I.S. L mungkin kosong */
  497. /* F.S. Melakukan alokasi sebuah elemen dan */
  498. /* menambahkan elemen list di akhir: elemen terakhir yang baru */
  499. /* bernilai X jika alokasi berhasil. Jika alokasi gagal: I.S.= F.S. */
  500. {
  501. address P;
  502.  
  503. P = Alokasi(X);
  504. if (P != Nil)
  505. {
  506. InsertLast(L,P);
  507. }
  508. }
  509. /*** PENGHAPUSAN ELEMEN ***/
  510. void DelVFirst (List *L, infotype *X)
  511. /* I.S. List L tidak kosong */
  512. /* F.S. Elemen pertama list dihapus: nilai info disimpan pada X */
  513. /* dan alamat elemen pertama di-dealokasi */
  514. {
  515. address P;
  516.  
  517. DelFirst(L,&P);
  518. (*X) = Info(P);
  519. Dealokasi(P);
  520. }
  521. void DelVLast (List *L, infotype *X)
  522. /* I.S. list tidak kosong */
  523. /* F.S. Elemen terakhir list dihapus: nilai info disimpan pada X */
  524. /* dan alamat elemen terakhir di-dealokasi */
  525. {
  526. {
  527. address P;
  528.  
  529. DelLast(L,&P);
  530. (*X) = Info(P);
  531. Dealokasi(P);
  532. }
  533. }
  534. /****************** PRIMITIF BERDASARKAN ALAMAT ******************/
  535. /*** PENAMBAHAN ELEMEN BERDASARKAN ALAMAT ***/
  536. void InsertFirst (List *L, address P)
  537. /* I.S. Sembarang, P sudah dialokasi */
  538. /* F.S. Menambahkan elemen ber-address P sebagai elemen pertama */
  539. {
  540. if(IsEmpty(*L))
  541. {
  542. Last(*L) = P;
  543. }
  544. else
  545. {
  546. Next(P) = First(*L);
  547. Prev(First(*L)) = P;
  548. }
  549.  
  550. First(*L) = P;
  551. }
  552. void InsertLast (List *L, address P)
  553. /* I.S. Sembarang, P sudah dialokasi */
  554. /* F.S. P ditambahkan sebagai elemen terakhir yang baru */
  555. {
  556.  
  557. if(IsEmpty(*L))
  558. {
  559. InsertFirst(L,P);
  560. }
  561. else
  562. {
  563. Prev(P) = Last(*L);
  564. Next(Last(*L)) = P;
  565. Last(*L) = P;
  566. }
  567. }
  568. void InsertAfter (List *L, address P, address Prec)
  569. /* I.S. Prec pastilah elemen list; P sudah dialokasi */
  570. /* F.S. Insert P sebagai elemen sesudah elemen beralamat Prec */
  571. {
  572. if(Last(*L) == Prec)
  573. {
  574. InsertLast(L, P);
  575. }
  576. else
  577. {
  578. Next(P) = Next(Prec);
  579. Prev(Next(Prec)) = P;
  580. Next(Prec) = P;
  581. Prev(P) = Prec;
  582. }
  583.  
  584.  
  585. }
  586. void InsertBefore (List *L, address P, address Succ)
  587. /* I.S. Succ pastilah elemen list; P sudah dialokasi */
  588. /* F.S. Insert P sebagai elemen sebelum elemen beralamat Succ */
  589. {
  590. if(First(*L) == Succ)
  591. {
  592. InsertFirst(L,P);
  593. }
  594. else
  595. {
  596. Prev(P) = Prev(Succ);
  597. Next(Prev(Succ)) = P;
  598. Next(P) = Succ;
  599. Prev(Succ) = P;
  600. }
  601. }
  602. /*** PENGHAPUSAN SEBUAH ELEMEN ***/
  603. void DelFirst (List *L, address *P)
  604. /* I.S. List tidak kosong */
  605. /* F.S. P adalah alamat elemen pertama list sebelum penghapusan */
  606. /* Elemen list berkurang satu (mungkin menjadi kosong) */
  607. /* First element yg baru adalah suksesor elemen pertama yang lama */
  608. {
  609. *P = First(*L);
  610. First(*L) = Next(*P);
  611. if(First(*L) == Nil)
  612. {
  613. Last(*L) = Nil;
  614. }
  615. else
  616. {
  617. Prev(First(*L)) = Nil;
  618. }
  619.  
  620. Next(*P)=Nil;
  621. }
  622. void DelLast (List *L, address *P)
  623. /* I.S. List tidak kosong */
  624. /* F.S. P adalah alamat elemen terakhir list sebelum penghapusan */
  625. /* Elemen list berkurang satu (mungkin menjadi kosong) */
  626. /* Last element baru adalah predesesor elemen pertama yg lama, jika ada */
  627. {
  628. *P = Last(*L);
  629. Last(*L) = Prev(*P);
  630. if(Last(*L) == Nil)
  631. {
  632. First(*L) = Nil;
  633. }
  634. else
  635. {
  636. Next(Last(*L)) = Nil;
  637. }
  638.  
  639. Next(*P)=Nil;
  640. }
  641. void DelP (List *L, infotype X)
  642. /* I.S. Sembarang */
  643. /* F.S. Jika ada elemen list beraddress P, dengan Info(P)=X */
  644. /* maka P dihapus dari list dan didealokasi */
  645. /* Jika tidak ada elemen list dengan Info(P)=X, maka list tetap */
  646. /* List mungkin menjadi kosong karena penghapusan */
  647. {
  648. if(!IsEmpty(*L))
  649. {
  650. address P = Search(*L,X);
  651. if(P!=Nil)
  652. {
  653. if(P == First(*L))
  654. {
  655. DelFirst(L,&P);
  656. }
  657. else
  658. {
  659. address Prev = First(*L);
  660. while(Next(Prev) != P)
  661. {
  662. Prev = Next(Prev);
  663. }
  664. DelAfter(L,&P,Prev);
  665. }
  666. Dealokasi(P);
  667. }
  668. }
  669. }
  670. void DelAfter (List *L, address *Pdel, address Prec)
  671. /* I.S. List tidak kosong. Prec adalah anggota list. */
  672. /* F.S. Menghapus Next(Prec): */
  673. /* Pdel adalah alamat elemen list yang dihapus */
  674. {
  675. if (Last(*L) == Next(Prec)){
  676. DelLast(L,Pdel);
  677. }
  678. else if (Next(Prec) != Nil)
  679. {
  680. *Pdel = Next(Prec);
  681. Next(Prec) = Next(*Pdel);
  682. Prev(Next(*Pdel)) = Prec;
  683. Prev(*Pdel) = Nil;
  684. Next(*Pdel) = Nil;
  685. }
  686. }
  687. void DelBefore (List *L, address *Pdel, address Succ)
  688. /* I.S. List tidak kosong. Succ adalah anggota list. */
  689. /* F.S. Menghapus Prev(Succ): */
  690. /* Pdel adalah alamat elemen list yang dihapus */
  691. {
  692. if(First(*L) == Prev(Succ)){
  693. DelFirst(L, Pdel);
  694. }
  695. else if(Prev(Succ) !=Nil)
  696. {
  697. *Pdel = Prev(Succ);
  698. Next(Prev(*Pdel)) = Succ;
  699. Prev(Succ) = Prev(*Pdel);
  700. Next(*Pdel) = Nil;
  701. Prev(*Pdel) = Nil;
  702. }
  703. }
  704. /****************** PROSES SEMUA ELEMEN LIST ******************/
  705. void PrintForward (List L)
  706. /* I.S. List mungkin kosong */
  707. /* F.S. Jika list tidak kosong, isi list dicetak dari elemen pertama */
  708. /* ke elemen terakhir secara horizontal ke kanan: [e1,e2,...,en] */
  709. /* Contoh : jika ada tiga elemen bernilai 1, 20, 30 akan dicetak: [1,20,30] */
  710. /* Jika list kosong : menulis [] */
  711. /* Tidak ada tambahan karakter apa pun di awal, akhir, atau di tengah */
  712. {
  713. if(IsEmpty(L))
  714. {
  715. printf("[]");
  716. }
  717. else
  718. {
  719. address P = First(L);
  720.  
  721. printf("[");
  722. while(P != Nil)
  723. {
  724. printf("%d", Info(P));
  725. if(Next(P) != Nil)
  726. {
  727. printf(",");
  728. }
  729. P=Next(P);
  730. }
  731. printf("]");
  732. }
  733. }
  734. void PrintBackward (List L)
  735. /* I.S. List mungkin kosong */
  736. /* F.S. Jika list tidak kosong, isi list dicetak dari elemen terakhir */
  737. /* ke elemen pertama secara horizontal ke kanan: [en,en-1,...,e2,e1] */
  738. /* Contoh : jika ada tiga elemen bernilai 1, 20, 30 akan dicetak: [30,20,1] */
  739. /* Jika list kosong : menulis [] */
  740. /* Tidak ada tambahan karakter apa pun di awal, akhir, atau di tengah */
  741. {
  742. if(IsEmpty(L))
  743. {
  744. printf("[]");
  745. }
  746. else
  747. {
  748. address P = Last(L);
  749.  
  750. printf("[");
  751. while(P != Nil)
  752. {
  753. printf("%d", Info(P));
  754. if(Prev(P) != Nil)
  755. {
  756. printf(",");
  757. }
  758. P=Prev(P);
  759. }
  760. printf("]");
  761. }
  762. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!