ListRr

/* Program   : ListR.c */
/* Deskripsi : file BODY modul stack berkait cara rekursif */
/* NIM/Nama  : 24060119120029/Hana Glorya Stefany*/
/* Tanggal   : 5 Desember 2020*/
/***********************************/
#include <stdio.h>
#include <stdlib.h>
#include "ListRr.h"



/****************** TEST LIST KOSONG ******************/
boolean IsEmpty (List L)
/* Mengirim true jika list kosong */
    {
    //Kamus Lokal

    //Algoritma
     return (L) == Nil;
    }

/****************** PEMBUATAN LIST KOSONG ******************/
void CreateList (List * L)
/* I.S. sembarang */
/* F.S. Terbentuk list kosong */
    {
    //Kamus Lokal

    //Algoritma
    (*L) =Nil;
    }

/****************** Manajemen Memori ******************/
address Alokasi (infotype X)
/* Mengirimkan address hasil alokasi sebuah elemen */
/* Jika alokasi berhasil, maka address tidak nil, dan misalnya */
/* menghasilkan P, maka info(P)=X, Next(P)=Nil */
/* Jika alokasi gagal, mengirimkan Nil */
    {
        //Kamus Lokal
        address P;

        //Algoritma
        P = (address) malloc(sizeof(ElmtList));
        if(P != Nil){
            info(P) = X;
            next(P) = Nil;
        }
    }
void Dealokasi (address P)
/* I.S. P terdefinisi */
/* F.S. P dikembalikan ke sistem */
/* Melakukan dealokasi/pengembalian address P */
    {
        //Kamus Lokal

        //ALgoritma
        info(P) = 0;
        next(P) = Nil;
        P = Nil;

    }
//Printinfo
void Printlist(List L){
    if (IsEmpty(L)){

    }
    else
    {
        printf(" %d ", info(L));
        Printlist(next(L));
    }

}
//untuk memasukkan elemen

List Konso (List L, infotype e)
{
    //kamus Lokal
    address P;

    //Algoritma

    P=Alokasi(e);
    if(P == Nil){
       return L;
    }
    else {
        next(P)= L;
        return P;

    }
}
List Konsi(List L, infotype e)
{
    //KamusLokal
    address P,Last;

    //Algoritma
    P=Alokasi(e);
    if (P == Nil){
        return L;
    }
    else{
        if (IsEmpty(L)){
            return L;
        }
        else {
            Last = L;
            while (next(Last) != Nil){
                Last = next(Last);
            }
            next(Last)=P;
            return L;
        }
    }
}

int FirstElmt(List L){
    return info(L);
}

List Tail(List L){
    return next(L);
}
List Reverse(List L)
/* { Mengirimkan invers list L} */
/* { Jika alokasi gagal, mengirimkan L }*/
{
 //Kamus Lokal

 //Algoritma
    if(IsEmpty(L)){
        return L;
    }
    else{
        Konsi(Reverse(Tail(L)),FirstElmt(L));
    }
}
int LastElmt(List L)
/* function LastElmt (L : List) -> InfoType */
/* { Mengirimkan elemen terakhir sebuah list L yang tidak kosong } */
{
    //Kamus Lokal
    List temp = L;
    //Algoritma
    return FirstElmt(Reverse(temp));
}
List Head(List L)
/* function Head (L : List) -> List */
/* { Mengirimkan list L tanpa elemen terakhirnya, mungkin yang dikirimkan adalah sebuah list kosong } */
{
    //Kamus Lokal

    //Algoritma
    return Reverse(Tail(Reverse(L)));
}


List Copy (List L){
    //Kamus Lokal

    //Algoritma
    if (IsEmpty(L)){
        return L;
    }
    else
    {
        return Konso(Copy(Tail(L)),FirstElmt(L));
    }
}

void MengCopy(List Lin, List *Lout){
    //Kamus Lokal
    List Ltemp;

    //Algortima
    if (IsEmpty(Lin)){
        (*Lout)=Lin;
    }
    else{
         MengCopy(Tail(Lin),(&Ltemp));
        (*Lout) = Konso(Ltemp,FirstElmt(Lin));
    }
}

List Concat(List L, List La)
{
    if(IsEmpty(L)){
        return Copy(La);
    }
    else
    {
        return Konso((Concat(Tail(L),La)),(FirstElmt(L)));
    }
}

List Concat2(List L1, List L2)
//function Concat2(L1, L2 : List) -> List
 //{ Mengirimkan salinan hasil konkatenasi list L1 dan L2 }
{
    //Kamus Lokal
    int temp;
    List Ltemp;
    //Algoritma
    printf("T");
    if(IsEmpty(L2)){ //Basis
       return Copy(L1);
    }
    else{ // rekurens
        temp = LastElmt(L2);
        printf("%d",temp);
        Ltemp = Concat(L1,Head(L2));
        return Konsi(Ltemp,temp);
    }
}

int NBElmtlist(List L)
{
    if (IsEmpty(L)){
        return 0;
    }
    else
    {
        return 1+NBElmtlist(next(L));
    }
}
void NBElmtlist1(List L,int *N)
{
    //Kammus Lokal
    int N1;

    //Algoritma
    if(IsEmpty(L)){
        (*N)=0;
    }
    else {
        NBElmtlist1(next(L),&N1);
        (*N)= 1 + N1;
    }
}
void NbElmtListAcc(List L, int Acc, int N)
{
    //Algoritma
    (Acc)=0;
    if(IsEmpty(L)) {
        N=Acc;
    }
    else {
        Acc = Acc+1;
        NbElmtListAcc(next(L),Acc,N);
    }
}
int Search(List L, infotype X)
{
    if(IsEmpty(L)){
        return false;
    }
    else {
        if(info(L)==X){
            return true;
        }
        else {
            Search(next(L),X);
        }
    }
}