void Konkat (List L1, List L2, List *L3) {
/* Kamus Lokal */
address P, Pt;
boolean gagal;
/* Algoritma */
CreateList(L3);
gagal = false;
P = First(L1);
while ((P != Nil)&&(!gagal)) {
Pt = Alokasi(Info(P));
if (Pt != Nil) {
InsertLast(L3,Pt);
P = Next(P);
} else {
gagal = true;
DelAll(L3);
}
}
if (!gagal) {
P = First(L2);
while ((P != Nil)&&(!gagal)) {
Pt = Alokasi(Info(P));
if (Pt != Nil) {
InsertLast(L3,Pt);
P = Next(P);
} else {
gagal = true;
DelAll(L3);
}
}
}
}
List FInversList (List L)
/* Mengirimkan list baru, hasil invers dari L */
/* dengan menyalin semua elemn list. Alokasi mungkin gagal. */
/* Jika alokasi gagal, hasilnya list kosong */
/* dan semua elemen yang terlanjur di-alokasi, harus didealokasi */
{
List InversedList;
addressList InversP, P = First(L);
int success = 1;
CreateEmptyList(&InversedList);
while (P != NULL && success) {
InversP = Alokasi(Info(P));
if (InversP != NULL) {
InsertFirst(&InversedList, InversP);
P = Next(P);
} else {
success = 0;
}
}
if (!success)
DelAll(&InversedList);
return InversedList;
}
List FCopyList (List L)
/* Mengirimkan list yang merupakan salinan L */
/* dengan melakukan alokasi. */
/* Jika ada alokasi gagal, hasilnya list kosong dan */
/* semua elemen yang terlanjur di-alokasi, harus didealokasi */
{
List CopiedList;
addressList CopyP, P = First(L);
int success = 1;
CreateEmptyList(&CopiedList);
while (P != NULL && success) {
CopyP = Alokasi(Info(P));
if (CopyP != NULL) {
InsertLast(&CopiedList, CopyP);
P = Next(P);
} else {
success = 0;
}
}
if (!success)
DelAll(&CopiedList);
return CopiedList;
}
/***** Primitif Add/Delete *****/
void AddPrio (Queue *Q, infotype X, int Pr)
/* Proses : Mengalokasi X dan menambahkan X pada bagian TAIL dari Q jika alokasi
berhasil dengan memperhatikan prioritas; jika alokasi gagal Q tetap */
/* I.S. Q mungkin kosong, X terdefinisi */
/* F.S. X menjadi elemen Q sesuai prioritas Pr,
Q tetap terurut mengecil sesuai prioritas */
{ /* Kamus Lokal */
address P,Pt,Prec;
boolean found;
/* Algoritma */
Alokasi(&Pt,X,Pr);
if(Pt!=Nil) {
P=Head(*Q);
Prec=Nil;
found=false;
while ( P!=Nil && !(found) ) {
if(Prio(P)<Pr) {
found=true;
}
//prio dengan angka terkecil memiliki prioritas paling kecil
else {
Prec=P;
P=Next(P);
}
}
if(Prec==Nil) {
Next(Pt)=Head(*Q);
Head(*Q)=Pt;
}
else {
Next(Pt)=Next(Prec);
Next(Prec)=Pt;
}
}
}
void PecahList (List *L1, List *L2, List L)
/* I.S. L mungkin kosong */
/* F.S. Berdasarkan L, dibentuk dua buah list L1 dan L2 */
/* L tidak berubah: untuk membentuk L1 dan L2 harus alokasi */
/* L1 berisi separuh elemen L dan L2 berisi sisa elemen L */
/* Jika elemen L ganjil, maka separuh adalah NbElmt(L) div 2 */
{
addressList P = First(L), PPecah;
int count = 0, half = NbElmt(L) / 2, success = 1;
CreateEmptyList(L1);
CreateEmptyList(L2);
while (P != NULL && success) {
count++;
PPecah = Alokasi(Info(P));
if (PPecah != NULL) {
if (count <= half) {
InsertLast(L1, PPecah);
} else {
InsertLast(L2, PPecah);
}
} else {
success = 0;
}
P = Next(P);
}
if (!success) {
DelAll(L1);
DelAll(L2);
}
}
DATA ArrayToListControl()
{
DATA P;
CreateData(&P);
int initial=1;
while(initial<=id)
{
DATA temp,last;
if(P==Nil)
{
P=Alokasi();
if(P==Nil)
{
printf("\nOut of Memory / Error in program\n");
}
else
{
P=ArrayToList(P,initial);
Next(P)=Nil;
}
}
else
{
temp=P;
while(temp!=Nil)
{
last=temp;
temp=Next(temp);
}
Next(last)=Alokasi();
last=Next(last);
if(last==Nil)
{
printf("\nOut of Memory / Error in program\n");
}
else
{
last=ArrayToList(last,initial);
Next(last)=Nil;
}
}
initial++;
}
return P;
}
void InsLast( Node *List, int value, int posisi)
{
Node P;
P = Alokasi(value,posisi);
if( P != Nil )
{
InsertLast(&(*List), P);
}
}
/*** PENAMBAHAN ELEMEN ***/
void InsVFirst(List *L, infotypeList X)
/* I.S. L mungkin kosong */
/* F.S. Melakukan alokasi sebuah elemen dan */
/* menambahkan elemen pertama dengan nilai X jika alokasi berhasil */
{
addressList P = Alokasi(X);
if (P != NULL)
InsertFirst(L, P);
}
void InsVFirst (List *L,infotype X) {
/* I.S. L mungkin kosong */
/* F.S. Melakukan alokasi sebuah elemen dan menambahkan elemen pertama dengan nilai
X jika alokasi berhasil */
address P = Alokasi(X);
if(P!=Nil)
InsertFirst(L,P);
else
printf("Allocation failed. \n");
}
void InsVLast(List *L, infotypeList X)
/* I.S. L mungkin kosong */
/* F.S. Melakukan alokasi sebuah elemen dan */
/* menambahkan elemen list di akhir: elemen terakhir yang baru */
/* bernilai X jika alokasi berhasil. Jika alokasi gagal: I.S.=F.S. */
{
addressList P = Alokasi(X);
if (P != NULL)
InsertLast(L, P);
}
void InsVLast (List *L, infotype X) {
/* Kamus Lokal */
address P;
/* Algoritma */
P = Alokasi(X);
if (P != Nil) {
InsertLast(L,P);
}
}
DATA InsertControl(DATA P)
{
system("clear");
DATA temp,last;
if(P==Nil)
{
P=Alokasi();
if(P==Nil)
{
printf("\nOut of Memory / Error in program\n");
}
else
{
id++;
P=Insert(P,id);
Next(P)=Nil;
}
}
else
{
temp=P;
while(temp!=Nil)
{
last=temp;
temp=Next(temp);
}
Next(last)=Alokasi();
last=Next(last);
if(last==Nil)
{
printf("\nOut of Memory / Error in program\n");
}
else
{
id++;
last=Insert(last,id);
Next(last)=Nil;
}
}
return (P);
}
void InsVLast (ListPlayer *L, InfoPlayer X)
/* I.S. L mungkin kosong
F.S. X ditambahkan sebagai elemen terakhir L
Proses : Melakukan alokasi sebuah elemen dan menambahkan elemen list di akhir :
elemen terakhir yang baru bernilai X jika alokasi berhasil.
Jika alokasi gagal: I.S.= F.S.
*/
{
AddressOfPlayer P=Alokasi(X);
InsertLast(L,P);
}
void InsVLast(List *L,infotype X) {
/* I.S. L mungkin kosong
F.S. Melakukan alokasi sebuah elemen dan menambahkan elemen list di sebelum
elemen akhir (elemen sebelum elemen dummy) bernilai X jika alokasi berhasil.
Jika alokasi gagal: I.S. = F.S. */
address P = Alokasi(X);
if(P!=Nil)
InsertLast(L,P);
else
printf("Allocation failed. \n");
}
void Konkat (List L1, List L2, List * L3)
/* I.S. L1 dan L2 sembarang */
/* F.S. L1 dan L2 tetap, L3 adalah hasil konkatenasi L1 & L2 */
/* Jika semua alokasi berhasil, maka L3 adalah hasil konkatenasi */
/* Jika ada alokasi yang gagal, semua elemen yang sudah dialokasi */
/* harus di-dealokasi dan L3=NULL */
/* Konkatenasi dua buah list : L1 & L2 menghasilkan L3 yang "baru" */
/* Elemen L3 adalah hasil alokasi elemen yang “baru”. */
/* Jika ada alokasi yang gagal, maka L3 harus bernilai NULL */
/* dan semua elemen yang pernah dialokasi didealokasi */
{
addressList PKonkat, P;
int success = 1;
CreateEmptyList(L3);
P = First(L1);
while (P != NULL && success) {
PKonkat = Alokasi(Info(P));
if (PKonkat != NULL) {
InsertLast(L3, PKonkat);
P = Next(P);
} else {
success = 0;
}
}
P = First(L2);
while (P != NULL && success) {
PKonkat = Alokasi(Info(P));
if (PKonkat != NULL) {
InsertLast(L3, PKonkat);
P = Next(P);
} else {
success = 0;
}
}
if (!success)
DelAll(L3);
}
void CpAlokList (List Lin, List *Lout) {
/* Kamus Lokal */
address P, Pt;
boolean gagal;
/* Algoritma */
CreateList(Lout);
gagal = false;
P = First(Lin);
while ((P != Nil)&&(!gagal)) {
Pt = Alokasi(Info(P));
if (Pt != Nil) {
InsertLast(Lout,Pt);
P = Next(P);
} else {
gagal = true;
DelAll(Lout);
}
}
}
List FCopyList (List L) {
/* Kamus Lokal */
address P, Pt;
List Lt;
boolean gagal;
/* Algoritma */
gagal = false;
CreateList(&Lt);
P = First(L);
while ((P != Nil)&&(!gagal)) {
Pt = Alokasi(Info(P));
if (Pt != Nil) {
InsertLast(&Lt,Pt);
P = Next(P);
} else {
gagal = true;
DelAll(&Lt);
}
}
return Lt;
}
List FInversList (List L) {
/* Kamus Lokal */
List Li;
address P, Pt;
boolean gagal;
/* Algoritma */
gagal = false;
CreateList(&Li);
P = First(L);
while ((P != Nil) && (!gagal)) {
Pt = Alokasi(Info(P));
if (Pt != Nil) {
InsertFirst(&Li, Pt);
P = Next(P);
} else {
DelAll(&Li);
gagal = true;
}
}
return Li;
}
void PecahList (List *L1, List *L2, List L) {
/* Kamus Lokal */
address P, Pt;
boolean gagal;
int i, N;
/* Algoritma */
CreateList(L1);
CreateList(L2);
gagal = false;
i = 1;
N = NbElmt(L)/2;
P = First(L);
while (P != Nil)&&(!gagal) {
Pt = Alokasi(Info(P));
if (i <= N) {
if (Pt != Nil) {
InsertLast(L1,Pt);
P = Next(P);
i++;
} else {
gagal = true;
DelAll(L1);
}
} else {
if (Pt != Nil) {
InsertLast(L2,Pt);
P = Next(P);
i++;
} else {
gagal = true;
DelAll(L2);
}
}
}
int main()
{
/* Kamus Lokal */
List MyList, List2, List3;
int i;
infotype isi;
address P, Prec;
/* Program */
CreateList (&MyList);
printf ("Jml Elemen List adalah : %d \n", NbElmt(MyList));
/* Menambah List di awal */
i = 1;
while (i <= 5)
{
InsVFirst (&MyList, i*5);
i++;
}
printf ("Hasil InsVFirst 5 x adalah : "); PrintInfo (MyList);
printf ("Node Maksimal = %d ",Max (MyList));
printf ("Node Minimal = %d ",Min (MyList));
printf ("Rata-rata = %d \n",Average (MyList));
/* Mencari suatu elemen di list */
P = Search(MyList, 15);
printf ("Search yang berhasil (15) : P = %d, Ketemu = %d \n",P,FSearch(MyList,P));
DelP (&MyList, 15);
/* Insert di Last */
printf ("Insert di akhir nilai 723 : ");
InsVLast (&MyList, 723);
PrintInfo (MyList);
/* Insert diantara 2 elemen */
printf ("Insert sebelum elemen 10 : ");
Prec = SearchPrec (MyList, 10);
P = Alokasi (2712);
if (P != Nil)
{ InsertAfter (&MyList, P, Prec); }
PrintInfo (MyList);
/* Menghapus elemen List */
printf ("\tHasil Delete dari elemen List :\n");
printf ("Jumlah elemen list = %d \n", NbElmt(MyList));
DelVFirst (&MyList, &isi);
printf ("DelVFirst adalah %d\t", isi);
DelVLast (&MyList, &isi);
printf ("DelVLast adalah %d\t", isi);
/* Menghapus elemen di tengah-tengah */
Prec = SearchPrec (MyList, 10); /* Node yang akan dihapus */
if (Prec != Nil)
{
DelAfter (&MyList, &P, Prec);
isi = Info(P);
DeAlokasi (P);
printf ("DelAfter adalah %d\n", isi);
}
printf ("Hasil setelah delete : ");
PrintInfo (MyList);
printf ("Insert sebelum elemen 5 : ");
Prec = SearchPrec (MyList, 5);
P = Alokasi (-987);
if (P != Nil)
{ InsertAfter (&MyList, P, Prec); }
PrintInfo (MyList);
/* Invers List */
printf ("\tHasil Invers dari List yang ada : \n");
printf ("Versi 1 : ");
List2 = FInversList (MyList);
PrintInfo (List2);
printf ("Versi 2 : ");
InversList (&MyList);
PrintInfo (MyList);
/* Copy List */
printf ("\tHasil Copy dari List yang ada : \n");
printf("Versi 1 : ");
CopyList (MyList, &List2);
PrintInfo (List2);
printf ("Versi 2 : ");
List3 = FCopyList (MyList);
PrintInfo (List3);
printf ("Versi 3 : ");
CpAlokList (MyList, &List2);
PrintInfo (List2);
/* Konkat */
printf("\tHasil Konkat Invers dan List asli : \n");
List2 = FInversList (MyList);
Konkat (List2, List3, &MyList);
printf("Versi 1 : ");
PrintInfo (MyList);
Konkat1 (&List2, &List3, &MyList);
printf("Versi 2 : ");
PrintInfo (MyList);
/* Pecah List */
PecahList (&List2, &List3, MyList);
printf ("\tHasil membagi dua list adalah : \n");
printf ("L1 = "); PrintInfo (List2);
printf ("L2 = "); PrintInfo (List3);
/* Finishing */
P = First(MyList);
DeAlokasi (P);
P = First(List2);
DeAlokasi (P);
P = First(List3);
DeAlokasi (P);
return 0;
}
