PENDAHULUAN

A. PERMASALAHAN
Minimum Spanning Tree dapat dibentuk dari Spanning Graph dengan menggunakan
algoritma Prim algoritma kruskal. Untuk mengimplementasikan algoritma prim tersebut
digunakan bahasa C dan pascal untuk membuat sebuah program Prims dan program
kruskal dengan masukan berupa Spanning Graph dan hasil keluaran berupa Minimum
Spanning Tree.

B. DASAR TEORI
Spanning Tree merupakan subgraph dari Spanning Graph dan berupa Tree yang tidak
memuat simpul yang circular (sirkuit). Spanning tree mempunyai minimum bobot (cost)
yang dapat terbentuk dari Spannign graph dengan menggunakan 2 algoritma, yaitu
algoritma Prim dan Kruskal. Pada program ini hanya akan digunakan algoritma Prim
untuk membentuk Minimum Spanning Tree.
Langkah-lagkah dalam mambentuk Minimum Spanning Tree dari suatu
Spanning Graph dengan menggunakan algoritma Prim adalah sebagai berikut :
1. Menentukan Tree T yang memuat edge dengan cost (bobot) minimum yang
dipilih.
2. Menambahkan Edge dengan bobot minimum pada Tree T yang incident dengan
vertex-vertex pada Tree T, dan Tree T tidak memuat simpul sirkuit.
3. Melakukan langkah ke-2 sampai n-2 kali, dengan n adalah jumlah vertex dalam
Graph G.
Algoritma Kruskal adalah juga tergolong algoritma greedy dalam teori graf yang
digunakan untuk mencari pohon merentang minimum. Algoritma ini pertama kali muncul
pada tahun 1956 dalam sebuah tulisan yang ditulis oleh Joseph Kruskal.
Algoritmanya:
1. Himpunan sisi dari G diurutkan membesar sesuai bobot sisi tersebut.
2. Buat T dengan memasukkan 1 sisi terpendek dari G tersebut.
3. Ulang (banyak sisi T = (banyak simpul G) -1)
a. Ambil sisi selanjutnya dari G.
b. Jika sisi itu tidak membuat sirkuit di T
- Masukkan sisi itu ke T.
- Masukkan simpul-simpul sisi itu ke T.

1
C. TUJUAN
Pembuatan program Prims dengan bahasa C dan program kruskal dengan pascal ini
bertujuan untuk meningkatkan pemahaman mahasiswa tentang implementasi
algoritma Prims dan algoritma kruskal untuk membentuk suatu Spanning Tree dari
suatu Spanning Graph. Selain itu diharapkan program ini mampu mempermudah
pengguna dalam mengimplementasikan algoritma Prim dan kruskal dan membentuk
suatu Spanning Tree dari suatu Spanning Graph.

Source Code Prims

/* Nama File : prims.c */
/* Deskripsi : */
/* Programmer: Kelompok 8*/
/* Tanggal : 17 Juni 2009 */

#include <stdio.h>
#include "boolean.h"

typedef struct{
char iv; /* variabel verteks ke-1*/
char fv; /* variabel verteks ke-2 */
int wght; /* variabel bobot */
}TabGraf;
typedef TabGraf TGraf[100];

/*Definisi dan Spesifikasi Prototype*/

void InputGraph(int MaxEdge, TGraf T1);
/* Prosedur input edge kedalam tabel graf */
/* I.S : Graf T1 belum terisi */
/* F.S : Graf T1 sudah terisi */

void InsertionSort (TGraf *T, int N);

2
/*mengurutkan tabel integer [1...N] dengan insertion*/
/*I.S. : isi tabel belum terurut*/
/*F.S. : tabel terurut berdasarkan bobot dari kecil ke besar*/

boolean IsInsident(char V1,char V2, TGraf THasil, int MaxEdge, int MaxTHasil);
/* Fungsi untuk mengecek apakah suatu edge bersisian dengan edge pada Tabel Hasil */
/* I.S : Graf T1 sudah terisi */
/* F.S : True jika bersisian */

boolean IsCircuit(char V1,char V2, TGraf THasil, int MaxEdge );

/* Fungsi untuk mengecek apakah suatu edge jika dimasukkan ke Tabel Hasil akan
timbul circuit? */
/* I.S : Graf T1 sudah terisi */
/* F.S : True jika edge yang dimasukkan menimbulkan circuit */

void PrintGraph(int MaxEdge, TGraf T);

/* Prosedur untuk menampilkan Tabel Graf input */
/* I.S : - */
/* F.S : Menampilkan T1 */

void PrintBobotMinimumGraph(int MaxEdge, TGraf T);

/* Prosedur untuk menampilkan Tabel Graf dengan total bobot minimum */
/* I.S : - */
/* F.S : Menampilkan THasil */

/*Program utama*/
int main()
{
/*Kamus*/
TGraf T1, T2, THasil;

3
int i, j, k;
int MaxEdge;
int MaxTHasil;
boolean circuit, insiden;
/*Algoritma*/
printf("!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~! \n");
printf(" ILMU KOMPUTER 2008 ! \n");
printf("!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~! \n");
printf("! KELOMPOK 8 REGULER 2 ! \n");
printf("!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~! \n");
printf("! AMALIA PUSPITASARI (J2F008088)! \n");
printf("! DEVI HENDRIYANI (J2F008095)! \n");
printf("! JHANI RONAL (J2F008109)! \n");
printf("! ROMDIYAH (J2F008128)! \n");
printf("! TRI ISWATI (J2F008130)! \n");
printf("!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~! \n");
printf("\n");
printf("Inputkan jumlah edge pada graf : ");
scanf("%d",&MaxEdge);
InputGraph(MaxEdge,T1);
PrintGraph(MaxEdge, T1);
InsertionSort(&T1,MaxEdge);
THasil[1] = T1[1]; /* nilai minimum dari T1 dimasukkan ke THasil */
MaxTHasil = 1;
j = 2;
for (i=2;i<=MaxEdge;i++)
{
circuit = IsCircuit(T1[i].iv, T1[i].fv, THasil, MaxTHasil );
insiden = IsInsident(T1[i].iv, T1[i].fv, THasil, MaxEdge, MaxTHasil);
if (!circuit && insiden)
{

4
 THasil[j] = T1[i];
j = j+1;
MaxTHasil = MaxTHasil+1;
}
}

PrintBobotMinimumGraph(MaxTHasil, THasil);
getch();
return 0;
}

/*---------------------------------------------------------------------------------*/
/*Body Prototype*/

void InputGraph(int MaxEdge, TGraf T1)

/* Prosedur input edge kedalam tabel graf */
/* I.S : - */
/* F.S : Graf T1 sudah terisi */
{
/*Kamus*/
int i;
/*Algoritma*/
for (i=1;i<=MaxEdge;i++)
{
printf("Edge ke - %d\n",i);
fflush(stdin);
printf("Inputkan vortex ke-1 : ");
scanf("%c",&T1[i].iv);
fflush(stdin);
printf("Inputkan vortex ke-2 : ");

5
 scanf("%c",&T1[i].fv);
printf("Inputkan bobot dari edge ke - %d : ",i);
scanf("%d",&T1[i].wght);
}
}

void InsertionSort (TGraf *T, int N){

/*mengurutkan tabel integer [1...N] dengan insertion*/
/*I.S. : isi tabel belum terurut*/
/*F.S. : tabel terurut dari kecil ke besar*/

/*kamus lokal*/
int i;
int pass;
TGraf Temp;
/*Algoritma*/
for (pass = 2;pass<=N;pass++){
Temp[0].iv = (*T)[pass].iv;
Temp[0].fv = (*T)[pass].fv;
Temp[0].wght= (*T)[pass].wght;
i = pass - 1;
while ((Temp[0].wght < (*T)[i].wght) && (i > 1) ){
(*T)[i+1].iv = (*T)[i].iv;
(*T)[i+1].fv = (*T)[i].fv;
(*T)[i+1].wght = (*T)[i].wght;
i = i - 1;
};
if (Temp[0].wght >= (*T)[i].wght)
{
(*T)[i+1].iv = Temp[0].iv;

6
 (*T)[i+1].fv = Temp[0].fv;
(*T)[i+1].wght = Temp[0].wght;
}
else
{
(*T)[i+1].iv = (*T)[i].iv;
(*T)[i+1].fv = (*T)[i].fv;
(*T)[i+1].wght = (*T)[i].wght;
(*T)[i].iv = Temp[0].iv;
(*T)[i].fv = Temp[0].fv;
(*T)[i].wght = Temp[0].wght;

};
};
};

boolean IsInsident(char V1,char V2, TGraf THasil, int MaxEdge, int MaxTHasil)
/* Fungsi untuk mengecek apakah suatu edge bersisian dengan edge pada Tabel Hasil */
/* I.S : Graf T1 sudah terisi */
/* F.S : True jika bersisian */
{
/*Kamus*/
int i,j;
boolean sisi;
/*Algoritma*/
sisi = false;
for(i=1;i<=MaxEdge;i++)
{
for(j=1;j<=MaxTHasil;j++)
{

7
 if (V1 == THasil[j].iv || V1 == THasil[j].fv || V2 == THasil[j].iv || V2 ==
THasil[j].fv)
sisi = true;
}
}

return sisi;
}

boolean IsCircuit(char V1,char V2, TGraf THasil, int MaxEdge )

/* Fungsi untuk mengecek apakah suatu edge jika dimasukkan ke Tabel Hasil akan
timbul circuit? */
/* I.S : Graf T1 sudah terisi */
/* F.S : True jika edge yang dimasukkan menimbulkan circuit */
{
/*Kamus*/
int i;
boolean circuit;
/*Algoritma*/
circuit = false;
if (V1 == V2)
{
circuit = true;
return circuit;
}
else
{
for(i=1;i<=MaxEdge;i++)
{

if(THasil[i].iv == V1)

8
 {
circuit = IsCircuit(THasil[i].fv, V2, THasil,MaxEdge);
}

}
return circuit;
}
}

void PrintGraph(int MaxEdge, TGraf T)

/* Prosedur untuk menampilkan Tabel Graf input */
/* I.S : - */
/* F.S : Menampilkan T1 */
{
/*Kamus*/
int i;
/*Algoritma*/
printf("\n\nTabel Graf T1 : \n");
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
printf("| Verteks 1 | Verteks 2 | Bobot |\n");
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
for (i=1;i<=MaxEdge;i++)
{
printf("| %c ",T[i].iv);
printf("| %c ",T[i].fv);
printf("| %d |\n",T[i].wght);
}
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
}

void PrintBobotMinimumGraph(int MaxEdge, TGraf T)

9
/* Prosedur untuk menampilkan Tabel Graf dengan total bobot minimum */
/* I.S : - */
/* F.S : Menampilkan THasil */
{
/*Kamus*/
int i;
int JumlahBobot;
/*Algoritma*/
printf("\n\nTabel Graf dengan Total Bobot Minimum : \n");
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
printf("| Verteks 1 | Verteks 2 | Bobot |\n");
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
JumlahBobot = 0;
for (i=1;i<=MaxEdge;i++)
{
JumlahBobot = JumlahBobot + T[i].wght;
printf("| %c ",T[i].iv);
printf("| %c ",T[i].fv);
printf("| %d |\n",JumlahBobot);
}
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
}

10
Source Code Kruskal
program kruskal;
uses wincrt;
var
{kamus}
i : integer;
x : integer; {banyaknya verteks, x > 0}
G : integer; {banyak edge dalam graph, z > 0}
z : integer; {banyaknya edge dalam spaning tree, z > 0}
xv : string; {edge, bukan angka}
e : integer; {weight , e > 0}
a : integer;
jum : integer; {total minimum spaning tree}

begin
{program}
{input harus sesuai harus sesuai agar tidak membingungkan anda}
write('masukkan banyaknya verteks : ');
readln(x);

z := x - 1; {rumus mencari banyak edge dalam spaning tree}

writeln('banyaknya edge dalam spaning tree: ',z);

writeln;

write('masukkan banyaknya edge dalam graph : ');

readln(G); {inisialisasi}

i := 1; {frist element}

while (i<=G) do

11
begin

write('masukkan edge ke-',i,' (pisahkan dengan koma) : ');

readln (xv);

write('masukkan weight dari edge ke-',i,' : ');

readln (e);

if (i<=G) then {eksekusi selama i <= G}

begin
writeln('edge ke-',i,' = {',xv,'} , weight edge ke- ',i,' = ',e);
writeln;
end;

i := i + 1; {next element}
if (i > G) then {eksekusi apabila i > G}

begin

a := 1; {frist element untuk looping}

jum := 0; {inisialisasi untuk addition}

while (a <= z) do

begin

writeln;

writeln(a,' edge dari ',z,' edge di spning tree');

12
 write('masukkan edge yang memiliki weight terkecil : ');
readln(xv);

write('masukkan weight dari edge tersebut : ');

readln(e); {frist element/ next element untuk addition}

jum := jum + e;
a := a + 1; {next element untuk looping}
end;
end;
end;
writeln;
write('total minimum spaning tree : ',jum);
{terminasi}

13
SCREEN SHOT
Prims

14
SCREEN SHOT
Kruskal

15