Esempio n. 1
0
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;
}
Esempio n. 4
0
/***** 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);
    }
}
Esempio n. 6
0
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;
}
Esempio n. 7
0
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);
}
Esempio n. 9
0
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);
}
Esempio n. 11
0
void InsVLast (List *L, infotype X) {
    /* Kamus Lokal */
    address P;

    /* Algoritma */
    P = Alokasi(X);
    if (P != Nil) {
      InsertLast(L,P);
    }
}
Esempio n. 12
0
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);
}
Esempio n. 14
0
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);
}
Esempio n. 16
0
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);
      }
    }
}
Esempio n. 17
0
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;
}
Esempio n. 18
0
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;
}
Esempio n. 19
0
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);
        }
      }
    }
Esempio n. 20
0
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;
}