1.

LISTREKURSIF
#include "listrek.h"
#include <stdio.h>
#include <stdlib.h>
/* PROTOTYPE */
/****************** TEST LIST KOSONG ******************/
boolean IsEmpty (List L){
return (L == Nil);
}
/****************** PEMBUATAN LIST KOSONG ******************/
void CreateEmpty (List *L){
*L = Nil;
}

/****************** Manajemen Memori ******************/

address Alokasi (infotype X){
/*Kamus Lokal*/
address P = (address) malloc (1 * sizeof (ElmtList));
/*Algoritma*/
if (P == Nil) return Nil;
Info(P) = X;
Next(P) = Nil;
return P;
}

void Dealokasi (address P){

free(P);
}
/****************** PRIMITIF BERDASARKAN NILAI ******************/
/*** PENAMBAHAN ELEMEN ***/
void InsVFirst (List *L, infotype X){
/* Kamus Lokal */
address P;
/* Algoritma */
P = Alokasi(X);
if (P != Nil) {
Next(P) = *L;
*L = P; }
}
void InsVLast (List *L, infotype X){
/* Kamus Lokal */
/* Algoritma */
if (IsEmpty(*L)) {
*L = Alokasi(X);
} else {
InsVLast(&(Next(*L)),X);
}
}

/*** PENGHAPUSAN ELEMEN ***/

void DelVFirst (List *L, infotype *X){
/* Kamus Lokal */
address P;
/* Algoritma */
*X = Info(*L);
P = *L;
*L = Next(*L);
Dealokasi(P);
}

void DelVLast (List *L, infotype *X){

/* Kamus Lokal */
address P;
/* Algoritma */
if (Next(*L) == Nil) { /* hanya 1 elemen */
*X = Info(*L);
P = *L;
*L = Nil;
Dealokasi(P);
} else { /* rekurens */
DelVLast(&(Next(*L)),&(*X));
}
}

/****************** PROSES SEMUA ELEMEN LIST ******************/

List Copy (List L){
/* Kamus Lokal */
List L1;
/* Algoritma */
if (IsEmpty(L)) { /* Basis-0 */
return Nil;
} else { /* Rekurens */
L1 = Copy(Next(L));
InsVFirst(&L1,Info(L));
return L1;
}
}
void MCopy (List Lin, List *Lout){
/* Kamus Lokal */
List L1;
/* Algoritma */
if (IsEmpty(Lin)) { /* Basis-0 */
*Lout = Nil;
} else { /* Rekurens */
MCopy(Next(Lin),&(*Lout));
InsVFirst(&(*Lout),Info(Lin));
}
}

List Concat (List L1, List L2){

/* Kamus Lokal */
List LTemp;
/* Algoritma */
if (IsEmpty(L1)) { /* Basis-0 */
return (Copy(L2));
} else { /* Rekurens */
LTemp = Concat(Next(L1),L2);
InsVFirst(&LTemp,Info(L1));
return LTemp;
}
}

void MConcat (List L1, List L2, List *LHsl){

/* Kamus Lokal */
/* Algoritma */
if (IsEmpty(L1)) { /* Basis-0 */
MCopy(L2,&(*LHsl));
 } else { /* Rekurens */
MConcat(Next(L1),L2,&(*LHsl));
InsVFirst(&(*LHsl),Info(L1));
}
}

void PrintList (List L){

/* Kamus Lokal */
/* Algoritma */
if (IsEmpty(L)) { /* Basis-0 */
/* do nothing */
} else { /* Rekurens */
printf("%d\n",Info(L));
PrintList(Next(L)); }
}

int NbElmtList (List L){

/* Kamus Lokal */
/* Algoritma */
if (IsEmpty(L)) {
return 0; /* Basis-0 */
} else { /* Rekurens */
return (1 + NbElmtList(Next(L)));
}
}

boolean Search (List L, infotype X){

/* Kamus Lokal */
/* Algoritma */
if (IsEmpty(L)) {
 return false; /* Basis-0 */
} else { /* Rekurens */
if (Info(L)==X) {
return true;
} else {
return Search(Next(L),X);
}
}
}