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.

C. TUJUAN
1

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); /*mengurutkan tabel integer [1...N] dengan insertion*/ 2

/*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; int i, j, k; 3

int MaxEdge; int MaxTHasil; boolean circuit, insiden; /*Algoritma*/ printf("!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~! \n"); printf(" printf("! printf("! printf("! printf("! printf("! printf("! printf("\n"); printf("Inputkan jumlah edge pada graf : "); scanf("%d",&MaxEdge); InputGraph(MaxEdge,T1); PrintGraph(MaxEdge, T1); InsertionSort(&T1,MaxEdge); THasil[1] = T1[1]; 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) { THasil[j] = T1[i]; 4 /* nilai minimum dari T1 dimasukkan ke THasil */ ILMU KOMPUTER 2008 KELOMPOK 8 REGULER 2 AMALIA PUSPITASARI DEVI HENDRIYANI JHANI RONAL ROMDIYAH TRI ISWATI ! \n"); ! \n"); (J2F008088)! \n"); (J2F008095)! \n"); (J2F008109)! \n"); (J2F008128)! \n"); (J2F008130)! \n"); printf("!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~! \n"); printf("!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~! \n");

printf("!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~! \n");

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 : "); scanf("%c",&T1[i].fv); 5

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; (*T)[i+1].fv = Temp[0].fv; 6

(*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++) { if (V1 == THasil[j].iv || V1 == THasil[j].fv || V2 == THasil[j].iv || V2 == THasil[j].fv) 7

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) { circuit = IsCircuit(THasil[i].fv, V2, THasil,MaxEdge); 8

} } 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("| printf("| } printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"); } void PrintBobotMinimumGraph(int MaxEdge, TGraf T) /* Prosedur untuk menampilkan Tabel Graf dengan total bobot minimum */ /* I.S : - */ 9 %c %c ",T[i].iv); ",T[i].fv);

printf("| %d |\n",T[i].wght);

/* 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("| printf("| } printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"); } %c %c ",T[i].iv); ",T[i].fv);

printf("| %d |\n",JumlahBobot);

Source Code Kruskal

10

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'); write('masukkan edge yang memiliki weight terkecil : '); 12

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}

SCREEN SHOT
13

Prims

SCREEN SHOT
14

Kruskal

15