mbah_bejo

ListRr

Dec 5th, 2020
659
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /* Program   : ListR.c */
  2. /* Deskripsi : file BODY modul stack berkait cara rekursif */
  3. /* NIM/Nama  : 24060119120029/Hana Glorya Stefany*/
  4. /* Tanggal   : 5 Desember 2020*/
  5. /***********************************/
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include "ListRr.h"
  9.  
  10.  
  11.  
  12. /****************** TEST LIST KOSONG ******************/
  13. boolean IsEmpty (List L)
  14. /* Mengirim true jika list kosong */
  15.     {
  16.     //Kamus Lokal
  17.  
  18.     //Algoritma
  19.      return (L) == Nil;
  20.     }
  21.  
  22. /****************** PEMBUATAN LIST KOSONG ******************/
  23. void CreateList (List * L)
  24. /* I.S. sembarang */
  25. /* F.S. Terbentuk list kosong */
  26.     {
  27.     //Kamus Lokal
  28.  
  29.     //Algoritma
  30.     (*L) =Nil;
  31.     }
  32.  
  33. /****************** Manajemen Memori ******************/
  34. address Alokasi (infotype X)
  35. /* Mengirimkan address hasil alokasi sebuah elemen */
  36. /* Jika alokasi berhasil, maka address tidak nil, dan misalnya */
  37. /* menghasilkan P, maka info(P)=X, Next(P)=Nil */
  38. /* Jika alokasi gagal, mengirimkan Nil */
  39.     {
  40.         //Kamus Lokal
  41.         address P;
  42.  
  43.         //Algoritma
  44.         P = (address) malloc(sizeof(ElmtList));
  45.         if(P != Nil){
  46.             info(P) = X;
  47.             next(P) = Nil;
  48.         }
  49.     }
  50. void Dealokasi (address P)
  51. /* I.S. P terdefinisi */
  52. /* F.S. P dikembalikan ke sistem */
  53. /* Melakukan dealokasi/pengembalian address P */
  54.     {
  55.         //Kamus Lokal
  56.  
  57.         //ALgoritma
  58.         info(P) = 0;
  59.         next(P) = Nil;
  60.         P = Nil;
  61.  
  62.     }
  63. //Printinfo
  64. void Printlist(List L){
  65.     if (IsEmpty(L)){
  66.  
  67.     }
  68.     else
  69.     {
  70.         printf(" %d ", info(L));
  71.         Printlist(next(L));
  72.     }
  73.  
  74. }
  75. //untuk memasukkan elemen
  76.  
  77. List Konso (List L, infotype e)
  78. {
  79.     //kamus Lokal
  80.     address P;
  81.  
  82.     //Algoritma
  83.  
  84.     P=Alokasi(e);
  85.     if(P == Nil){
  86.        return L;
  87.     }
  88.     else {
  89.         next(P)= L;
  90.         return P;
  91.  
  92.     }
  93. }
  94. List Konsi(List L, infotype e)
  95. {
  96.     //KamusLokal
  97.     address P,Last;
  98.  
  99.     //Algoritma
  100.     P=Alokasi(e);
  101.     if (P == Nil){
  102.         return L;
  103.     }
  104.     else{
  105.         if (IsEmpty(L)){
  106.             return L;
  107.         }
  108.         else {
  109.             Last = L;
  110.             while (next(Last) != Nil){
  111.                 Last = next(Last);
  112.             }
  113.             next(Last)=P;
  114.             return L;
  115.         }
  116.     }
  117. }
  118.  
  119. int FirstElmt(List L){
  120.     return info(L);
  121. }
  122.  
  123. List Tail(List L){
  124.     return next(L);
  125. }
  126. List Reverse(List L)
  127. /* { Mengirimkan invers list L} */
  128. /* { Jika alokasi gagal, mengirimkan L }*/
  129. {
  130.  //Kamus Lokal
  131.  
  132.  //Algoritma
  133.     if(IsEmpty(L)){
  134.         return L;
  135.     }
  136.     else{
  137.         Konsi(Reverse(Tail(L)),FirstElmt(L));
  138.     }
  139. }
  140. int LastElmt(List L)
  141. /* function LastElmt (L : List) -> InfoType */
  142. /* { Mengirimkan elemen terakhir sebuah list L yang tidak kosong } */
  143. {
  144.     //Kamus Lokal
  145.     List temp = L;
  146.     //Algoritma
  147.     return FirstElmt(Reverse(temp));
  148. }
  149. List Head(List L)
  150. /* function Head (L : List) -> List */
  151. /* { Mengirimkan list L tanpa elemen terakhirnya, mungkin yang dikirimkan adalah sebuah list kosong } */
  152. {
  153.     //Kamus Lokal
  154.  
  155.     //Algoritma
  156.     return Reverse(Tail(Reverse(L)));
  157. }
  158.  
  159.  
  160. List Copy (List L){
  161.     //Kamus Lokal
  162.  
  163.     //Algoritma
  164.     if (IsEmpty(L)){
  165.         return L;
  166.     }
  167.     else
  168.     {
  169.         return Konso(Copy(Tail(L)),FirstElmt(L));
  170.     }
  171. }
  172.  
  173. void MengCopy(List Lin, List *Lout){
  174.     //Kamus Lokal
  175.     List Ltemp;
  176.  
  177.     //Algortima
  178.     if (IsEmpty(Lin)){
  179.         (*Lout)=Lin;
  180.     }
  181.     else{
  182.          MengCopy(Tail(Lin),(&Ltemp));
  183.         (*Lout) = Konso(Ltemp,FirstElmt(Lin));
  184.     }
  185. }
  186.  
  187. List Concat(List L, List La)
  188. {
  189.     if(IsEmpty(L)){
  190.         return Copy(La);
  191.     }
  192.     else
  193.     {
  194.         return Konso((Concat(Tail(L),La)),(FirstElmt(L)));
  195.     }
  196. }
  197.  
  198. List Concat2(List L1, List L2)
  199. //function Concat2(L1, L2 : List) -> List
  200.  //{ Mengirimkan salinan hasil konkatenasi list L1 dan L2 }
  201. {
  202.     //Kamus Lokal
  203.     int temp;
  204.     List Ltemp;
  205.     //Algoritma
  206.     printf("T");
  207.     if(IsEmpty(L2)){ //Basis
  208.        return Copy(L1);
  209.     }
  210.     else{ // rekurens
  211.         temp = LastElmt(L2);
  212.         printf("%d",temp);
  213.         Ltemp = Concat(L1,Head(L2));
  214.         return Konsi(Ltemp,temp);
  215.     }
  216. }
  217.  
  218. int NBElmtlist(List L)
  219. {
  220.     if (IsEmpty(L)){
  221.         return 0;
  222.     }
  223.     else
  224.     {
  225.         return 1+NBElmtlist(next(L));
  226.     }
  227. }
  228. void NBElmtlist1(List L,int *N)
  229. {
  230.     //Kammus Lokal
  231.     int N1;
  232.  
  233.     //Algoritma
  234.     if(IsEmpty(L)){
  235.         (*N)=0;
  236.     }
  237.     else {
  238.         NBElmtlist1(next(L),&N1);
  239.         (*N)= 1 + N1;
  240.     }
  241. }
  242. void NbElmtListAcc(List L, int Acc, int N)
  243. {
  244.     //Algoritma
  245.     (Acc)=0;
  246.     if(IsEmpty(L)) {
  247.         N=Acc;
  248.     }
  249.     else {
  250.         Acc = Acc+1;
  251.         NbElmtListAcc(next(L),Acc,N);
  252.     }
  253. }
  254. int Search(List L, infotype X)
  255. {
  256.     if(IsEmpty(L)){
  257.         return false;
  258.     }
  259.     else {
  260.         if(info(L)==X){
  261.             return true;
  262.         }
  263.         else {
  264.             Search(next(L),X);
  265.         }
  266.     }
  267. }
  268.  
RAW Paste Data