Iterasi Algoritma Kruskal

Tugas Struktur Data E

Alexander 5025201247
 typedef struct edge {
Pada program algoritma kruskal, dibuat  int u, v, w;
dua tipe data berbentuk struct yaitu edge  } edge;

yang berfungsi untuk menyimpan vertex  typedef struct edge_list {

dan weight serta edgelist yang berfungsi  edge data[MAX];
untuk menyimpan edge. Graf  int n;
} edge_list;
digambarkan sebagai array dua dimensi 
berukuran V*V. Didefinisikan juga  edge_list elist;
beberapa fungsi yaitu kruskalAlgo() untuk 
int Graph[11][11]={0}, n;
algoritma kruskal, find() untuk mencari  edge_list spanlist;
vertex, applyUnion() untuk melihat 
apakah gabungan membentuk cycle atau  void kruskalAlgo();
int find(int belongs[], int vertexno);
tidak, sort untuk mengurutkan elemen  void applyUnion(int belongs[], int c1, int c2);
weigth, dan print untuk mencetak hasil. void sort();
void print();
 void kruskalAlgo() {
int belongs[MAX], i, j, cno1, cno2;
elist.n = 0;

for (i = 1; i < n; i++)

for (j = 0; j < i; j++) {
if (Graph[i][j] != 0) {
elist.data[elist.n].u = i;
elist.data[elist.n].v = j;
elist.data[elist.n].w = Graph[i][j];
elist.n++;
Berikut merupakan fungsi kruskalAlgo(). Mula- }
mula, data setiap vertex dan edge dimasukkan ke  }

dalam elist.data dan kemudian disort  sort();

berdasarkan weight tiap edge. Algoritma 
kemudian membuat array belongs[i] dan variabel  for (i = 0; i < n; i++)
belongs[i] = i;
spanlist yang kemudian akan digunakan untuk 
mencari union dengan fungsi applyUnion. spanlist.n = 0;

for (i = 0; i < elist.n; i++) {

cno1 = find(belongs, elist.data[i].u);
cno2 = find(belongs, elist.data[i].v);

if (cno1 != cno2) {
spanlist.data[spanlist.n] = elist.data[i];
spanlist.n = spanlist.n + 1;
applyUnion(belongs, cno1, cno2);
}
}
}
 addEdge(0,1,2);
addEdge(0,3,3);
addEdge(0,4,2);
 Berikut merupakan iterasi dengan input sebagai  addEdge(0,9,1);
berikut. Graf diambil dari figur 9.81 dan dimasukkan  addEdge(1,2,2);
ke dalam program menggunakan adjacency list. addEdge(2,4,2);
addEdge(2,5,1);
addEdge(2,10,4);
addEdge(3,9,4);
addEdge(3,6,2);
addEdge(3,4,3);
addEdge(4,6,1);
addEdge(4,7,2);
addEdge(4,8,3);
addEdge(4,5,3);
addEdge(5,10,3);
addEdge(5,8,1);
addEdge(6,9,6);
addEdge(6,7,6);
addEdge(7,8,6);
addEdge(8,10,4);
 void kruskalAlgo() {
int belongs[MAX], i, j, cno1, cno2;
elist.n = 0;

for (i = 1; i < n; i++)

A B 2 for (j = 0; j < i; j++) {
if (Graph[i][j] != 0) {
elist.data[elist.n].u = i;
Seluruh weight dan info vertex dimasukkan elist.data[elist.n].v = j;
A D 3 elist.data[elist.n].w = Graph[i][j];
ke dalam elist.data.
elist.n++;
}
}
A E 2
sort();

for (i = 0; i < n; i++)

belongs[i] = i;

spanlist.n = 0;

for (i = 0; i < elist.n; i++) {

cno1 = find(belongs, elist.data[i].u);
cno2 = find(belongs, elist.data[i].v);

if (cno1 != cno2) {
spanlist.data[spanlist.n] = elist.data[i];
spanlist.n = spanlist.n + 1;
applyUnion(belongs, cno1, cno2);
}
}
}
 void kruskalAlgo() {
int belongs[MAX], i, j, cno1, cno2;
elist.n = 0;

for (i = 1; i < n; i++)

A s 1 for (j = 0; j < i; j++) {
if (Graph[i][j] != 0) {
elist.data[elist.n].u = i;
Seluruh weight kemudian diurutkan. elist.data[elist.n].v = j;
C F 1 elist.data[elist.n].w = Graph[i][j];
elist.n++;
}
}
E G 1
sort();

for (i = 0; i < n; i++)

belongs[i] = i;

spanlist.n = 0;

for (i = 0; i < elist.n; i++) {

cno1 = find(belongs, elist.data[i].u);
cno2 = find(belongs, elist.data[i].v);

if (cno1 != cno2) {
spanlist.data[spanlist.n] = elist.data[i];
spanlist.n = spanlist.n + 1;
applyUnion(belongs, cno1, cno2);
}
}
}
 void kruskalAlgo() {
Dibuat array belongs untuk mendeteksi  int belongs[MAX], i, j, cno1, cno2;
cycle atau siklik elist.n = 0;

for (i = 1; i < n; i++)

1 2 3 A s 1 for (j = 0; j < i; j++) {
if (Graph[i][j] != 0) {
elist.data[elist.n].u = i;
elist.data[elist.n].v = j;
C F 1 elist.data[elist.n].w = Graph[i][j];
Apabila tidak terjadi cycle, edge akan elist.n++;
dimasukkan dalam spanlist }
}
E G 1
sort();

 for (i = 0; i < n; i++)

belongs[i] = i;

spanlist.n = 0;

for (i = 0; i < elist.n; i++) {

cno1 = find(belongs, elist.data[i].u);
cno2 = find(belongs, elist.data[i].v);

if (cno1 != cno2) {
spanlist.data[spanlist.n] = 
elist.data[i];
spanlist.n = spanlist.n + 1;
applyUnion(belongs, cno1, cno2);
}
}
}
 void kruskalAlgo() {
Proses dilakukan hingga didapat jalur  int belongs[MAX], i, j, cno1, cno2;
sebagai berikut : elist.n = 0;

for (i = 1; i < n; i++)

for (j = 0; j < i; j++) {
if (Graph[i][j] != 0) {
elist.data[elist.n].u = i;
elist.data[elist.n].v = j;
elist.data[elist.n].w = Graph[i][j];
elist.n++;
}
}

sort();

for (i = 0; i < n; i++)

belongs[i] = i;

spanlist.n = 0;

for (i = 0; i < elist.n; i++) {

cno1 = find(belongs, elist.data[i].u);
cno2 = find(belongs, elist.data[i].v);

if (cno1 != cno2) {
spanlist.data[spanlist.n] = elist.data[i];
spanlist.n = spanlist.n + 1;
applyUnion(belongs, cno1, cno2);
}
}
}
 Berikut merupakan iterasi dengan input sebagai 
berikut. Graf diambil dari figur 9.82 dan dimasukkan 
ke dalam program menggunakan adjacency list. addEdge(0,1,5);
addEdge(0,2,3);
addEdge(0,3,2);
addEdge(1,2,2);
addEdge(1,4,3);
addEdge(1,6,1);
addEdge(2,3,7);
addEdge(2,4,7);
addEdge(3,4,2);
addEdge(3,5,6);
addEdge(4,5,1);
addEdge(4,6,1);
 void kruskalAlgo() {
int belongs[MAX], i, j, cno1, cno2;
elist.n = 0;

for (i = 1; i < n; i++)

A B 5 for (j = 0; j < i; j++) {
if (Graph[i][j] != 0) {
elist.data[elist.n].u = i;
Seluruh weight dan info vertex dimasukkan elist.data[elist.n].v = j;
A C 3 elist.data[elist.n].w = Graph[i][j];
ke dalam elist.data.
elist.n++;
}
}
A D 2
sort();

for (i = 0; i < n; i++)

belongs[i] = i;

spanlist.n = 0;

for (i = 0; i < elist.n; i++) {

cno1 = find(belongs, elist.data[i].u);
cno2 = find(belongs, elist.data[i].v);

if (cno1 != cno2) {
spanlist.data[spanlist.n] = elist.data[i];
spanlist.n = spanlist.n + 1;
applyUnion(belongs, cno1, cno2);
}
}
}
 void kruskalAlgo() {
int belongs[MAX], i, j, cno1, cno2;
elist.n = 0;

for (i = 1; i < n; i++)

F E 1 for (j = 0; j < i; j++) {
if (Graph[i][j] != 0) {
elist.data[elist.n].u = i;
Seluruh weight kemudian diurutkan. elist.data[elist.n].v = j;
G B 1 elist.data[elist.n].w = Graph[i][j];
elist.n++;
}
}
E G 1
sort();

for (i = 0; i < n; i++)

belongs[i] = i;

spanlist.n = 0;

for (i = 0; i < elist.n; i++) {

cno1 = find(belongs, elist.data[i].u);
cno2 = find(belongs, elist.data[i].v);

if (cno1 != cno2) {
spanlist.data[spanlist.n] = elist.data[i];
spanlist.n = spanlist.n + 1;
applyUnion(belongs, cno1, cno2);
}
}
}
 void kruskalAlgo() {
Dibuat array belongs untuk mendeteksi  int belongs[MAX], i, j, cno1, cno2;
cycle atau siklik elist.n = 0;

for (i = 1; i < n; i++)

1 2 3 A s 1 for (j = 0; j < i; j++) {
if (Graph[i][j] != 0) {
elist.data[elist.n].u = i;
elist.data[elist.n].v = j;
C F 1 elist.data[elist.n].w = Graph[i][j];
Apabila tidak terjadi cycle, edge akan elist.n++;
dimasukkan dalam spanlist }
}
E G 1
sort();

 for (i = 0; i < n; i++)

belongs[i] = i;

spanlist.n = 0;

for (i = 0; i < elist.n; i++) {

cno1 = find(belongs, elist.data[i].u);
cno2 = find(belongs, elist.data[i].v);

if (cno1 != cno2) {
spanlist.data[spanlist.n] = 
elist.data[i];
spanlist.n = spanlist.n + 1;
applyUnion(belongs, cno1, cno2);
}
}
}
 void kruskalAlgo() {
Proses dilakukan hingga didapat jalur  int belongs[MAX], i, j, cno1, cno2;
sebagai berikut : elist.n = 0;

for (i = 1; i < n; i++)

for (j = 0; j < i; j++) {
if (Graph[i][j] != 0) {
elist.data[elist.n].u = i;
elist.data[elist.n].v = j;
elist.data[elist.n].w = Graph[i][j];
elist.n++;
}
}

sort();

 for (i = 0; i < n; i++)

belongs[i] = i;

spanlist.n = 0;

for (i = 0; i < elist.n; i++) {

cno1 = find(belongs, elist.data[i].u);
cno2 = find(belongs, elist.data[i].v);

if (cno1 != cno2) {
spanlist.data[spanlist.n] = 
elist.data[i];
spanlist.n = spanlist.n + 1;
applyUnion(belongs, cno1, cno2);
}
}
}