LAPORAN PRAKTIKUM ALGORITMA DAN STRUKTUR (6)

LAPORAN PRAKTIKUM
ALGORITMA DAN STRUKTUR DATA II
MODUL
Pohon n-er

Disusun Oleh :
Syukur Jaya Mendrofa
201501072
Kelas: C

Dosen Pengampu :
Oskar Ika Adi Nugroho, ST., MT

JURUSAN SISTEM INFORMASI
SEKOLAH TINGGI ILMU KOMPUTER “YOS SUDARSO”
PURWOKERTO
2016

BAB I
DASAR TEORI
Pohon n-er

Pohon n-er adalah struktur pohon yang memiliki simpul turunan lebih dari dua.
Contoh Pohon n-er :

Pada pohon n-er dapat dilakukan kunjungan pada simpul-simpulnya seperti pada pohon
biner.


Jika dilakukan kunjungan pada simpul-simpul pohon n-er diatas secara preorder
akan menghasilkan :
A-B-E-F-C-G-D-H-I-J-K-L-M



Jika dilakukan kunjungan pada simpul-simpul pohon n-er diatas secara postorder
akan menghasilkan :
E-F-B-G-C-H-I-K-L-M-J-D-A



Jika dilakukan kunjungan pada simpul-simpul pohon n-er diatas secara levelorder

akan menghasilkan :
A-B-C-D-E-F-G-H-I-J-K-L-M

BAB II
TUGAS
#include
#include
typedef struct smp *alamatsimpul;
typedef struct smp{
char info;
alamatsimpul sibling;
alamatsimpul child;
} simpul;
typedef struct{
simpul *root;
} tree;
void makeTree(char c, tree *T) {
simpul *node;
node = (simpul *) malloc(sizeof (simpul));
node->info = c;

node->sibling = NULL;
node->child = NULL;
(*T) .root = node;
}
void addChild(char c, simpul **root){
if((*root) != NULL){
/*jika root tidak kosong*/
simpul *node;
node = (simpul *) malloc (sizeof (simpul));
node->info = c;
node->child = NULL;
if ((*root)->child == NULL){
/*simpul baru menjadi anak pertaam*/
node->sibling = NULL;
(*root)->child = node;
}
else {
if ((*root) -> child->sibling == NULL){
/*jika simpul baru menjadi anak kedua*/
node->sibling = (*root)->child;

(*root)->child->sibling = node;
}
else {
simpul *last = (*root)->child;
/*mencari simpul anakterakhir */
while(last->sibling !=(*root)->child){

last = last->sibling;
}
node->sibling = (*root)->child;
last->sibling = node;
}
}
}
}
void delChild(char c, simpul **root){
simpul *node = (*root)-> child;
if (node != NULL){
if(node->sibling == NULL){
/*jika hanya mempunyai satu anak*/

if((*root)->child->info == c){
(*root)->child = NULL;
free (node);
}
else {
printf("tidak ada simpulanak dengan info karakter masukan \n");
}
}
else{
/*jika memiliki banyak anak*/
simpul *prec = NULL;
/*mencari simpul yang akan dihapus*/
int ketemu = 0;
while((node->sibling !=(*root)->child)&&(ketemu == 0)){
if (node->info == c){
ketemu = 1;
}
else{
prec = node;
node = node->sibling;

}
}
/*memproses simpul anak terakhir karena belum terproses dalam pengulangan*/
if((ketemu == 0) &&(node->info == c)){
ketemu = 1;
}
if(ketemu == 1){
simpul *last = (*root)->child;
/*mencari simpul anak terakhir*/
while(last->sibling !=(*root)-> child){
last = last->sibling;
}
if(prec == NULL){
/*jika simpul yang dihapus anak pertama*/
if((node->sibling == last)&&(last->sibling == (*root)->child)){

/*jika hanya ada 2 anak*/
(*root)->child = last;
last->sibling = NULL;
}

else{
(*root)->child = node -> sibling;
last->sibling =(*root)->child;
}
}
else{
if((prec == (*root)->child) &&(last->sibling == (*root)->child)){
/*jika hanya ada 2 simpul anak, yang dihapus anak kedua*/
(*root)->child->sibling = NULL;
}
else{
prec->sibling = node ->sibling;
node->sibling = NULL;
}
}
free(node);
}
else{
printf("Tidak ada simpul anak dengan info karakter masukan /n ");
}

}
}
}
simpul* findSimpul(char c, simpul *root){
simpul *hasil = NULL;
if(root != NULL){
if(root -> info == c){
hasil = root;
}
else{
simpul *node = root->child;
if(node != NULL){
if(node-> sibling == NULL){
/*jika memiliki satu anak*/
if(node->info == c){
hasil = node;
}
else{
hasil = findSimpul (c, node);
}

}
else{
/*jika memiliki banyak anak*/
int ketemu = 0;
while((node->sibling != root->child)

&&(ketemu == 0)){
if(node->info == c){
hasil = node;
ketemu = 1;
}
else{
hasil = findSimpul(c, node);
node = node -> sibling;
}
}
/*memproses simpul anak terakhir karena belum terproses dalam pengulangan*/
if(ketemu == 0){
if(node->info == c){
hasil = node;

}
else{
hasil = findSimpul(c, node);
}
}
}
}
}
}
return hasil;
}
void printTreePreOrder(simpul *root){
if(root != NULL){
printf(" %c ", root-> info);
simpul *node = root-> child;
if(node != NULL){
if(node->sibling == NULL){
/*jika memiliki satu anak*/
printTreePreOrder (node);
}

else{
/*jika memiliki banyak anak*/
/*mencetak simpul anak*/
while(node->sibling != root->child){
printTreePreOrder(node);
node = node->sibling;
}
/*memproses simpul anak terakhir karena belum terproses dalam pengulanga*/
printTreePreOrder(node);
}
}
}
}
void printTreePostOrder(simpul *root){

if(root != NULL){
simpul *node = root->child;
if(node != NULL){
if(node->sibling == NULL){
/*jika memiliki satu anak*/
printTreePostOrder(node);
}
else{
/*jika memiliki banyak anak*/
/*mencetak simpul anak*/
while(node->sibling !=
root->child){
printTreePostOrder(node);
node = node -> sibling;
}
/*memproses simpul anak terakhir karena belum terproses dalam pengulangan*/
printTreePostOrder(node);
}
}
printf(" %c ", root -> info);
}
}
void printTreeLevelOrderNext(simpul *root){
if(root != NULL){
simpul *node = root->child;
if(node != NULL){
if(node->sibling == NULL){
/*jika memiliki satu anak*/
printf(" %c ", node->info);
printTreeLevelOrderNext (node);
}
else{
while(node->sibling != root->child){
printf(" %c ", node-> info);
node= node->sibling;
}
/*memproses simpul anak terakhir karena belum terproses dalam pengulanagn*/
printf(" %c ", node -> info);
node = root->child;
while(node->sibling !=
root->child){
printTreeLevelOrderNext(node);
node = node->sibling;
}
/*memproses simpul anak terakhir karena belum terproses dalam pengulangan*/
printTreeLevelOrderNext(node);
}
}
}

}
void printTreeLevelOrder(simpul *root){
if(root != NULL){
printf(" %c ", root -> info);
printTreeLevelOrderNext(root);
}
}
void copyTree(simpul *root1,simpul **root2){
if(root1 != NULL){
(*root2) = (simpul *) malloc(sizeof
(simpul));
(*root2)->info = root1->info;
(*root2)->sibling = NULL;
(*root2)->child = NULL;
if(root1->child != NULL){
if(root1->child->sibling == NULL){
/*jika memiliki satu anak*/
copyTree(root1->child, &(*root2)->child);
}
else{
/*jika memiliki banyak anak*/
simpul *node1 = root1->child;
simpul *node2 =
(*root2)->child;
while(node1->sibling !=
root1->child){
copyTree(node1, &node2);
node1 = node1->sibling;
node2 = node2->sibling;
}
/*memproses simpul anak terakhir karena belum terproses dalam pengulangan*/
copyTree(node1, &node2);
}
}
}
}
int isEqual(simpul *root1, simpul *root2){
int hasil = 1;
if((root1 != NULL) && (root2 != NULL)){
if(root1-> info != root2 -> info){
hasil = 0;
}
else{
if((root1->child != NULL) && (root2->child != NULL)){
if(root1->child->sibling == NULL){
/*jika memiliki satu anak*/

hasil =
isEqual(root1->child, root2->child);
}
else{
/*jika memiliki banyak anak*/
simpul *node1 = root1->child;
simpul *node2 = root2->child;
while(node1->sibling != root1->child){
if((node1 != NULL) && (node2 != NULL)) {
hasil =
isEqual(node1, node2);
node1 = node1-> sibling;
node2 = node2-> sibling;
}
else{
hasil = 0;
break;
}
}
/*memproses simpul anak terakhir karena belum terproses dalam pengulangan*/
hasil =
isEqual(node1, node2);
}
}
}
}
else{
if((root1 != NULL) || (root2 != NULL)){
hasil = 0;
}
}
return hasil;
}
int main(){
tree T;
makeTree('A', &T);
addChild('B', &T.root);
addChild('C', &T.root);
addChild('D', &T.root);
simpul *node = findSimpul('B', T.root);
if(node != NULL){
addChild('E', &node);
addChild('F', &node);
}
node = findSimpul('C', T.root);
if(node != NULL){
addChild('G', &node);
}

node = findSimpul('D', T.root);
if(node != NULL){
addChild('H', &node);
addChild('I', &node);
addChild('J', &node);
}
node = findSimpul('J', T.root);
if(node != NULL){
addChild('K', &node);
addChild('L', &node);
addChild('M', &node);
}
printf(" WELCOME SYUKUR JAYA MENDROFA \n");
printf(" ================== \n");
printf(" PreOrder \n");
printTreePreOrder(T.root);
printf("\n ================== \n");
printf(" PostOrder \n");
printTreePostOrder(T.root);
printf("\n ================== \n");
printf(" levelOrder \n");
printTreeLevelOrder(T.root);
printf("\n ================== \n");
tree T2;
copyTree(T.root, &T2.root);
if(isEqual(T.root, T2.root) == 1){
printf(" pohon sama \n");
}
else{
printf(" pohon tidak sama \n");
}
node = findSimpul ('J', T.root);
if(node != NULL){
delChild('K', &node);
delChild('L', &node);
delChild('M', &node);
}
printf(" =============== \n");
printf(" preOrder setelah dihapus \n");
printTreePreOrder(T.root);
printf(" \n =============== \n");
return 0;
}
Hasil Outputnya :

ANALISA PRORGRAM
Cara kerja void PrintTreePreOrder

Mempunyai urutan :
 Cetak isi simpul yang dikunjungi (simpul akar)
 Kunjungi cabang kiri
 Kunjungi cabang kanan
Sehingga output menghasilkan keluaran di layar :

Cara Kerja void PrintTreePostOrder

Mempunyai urutan :
 Kunjungi cabang kiri
 Kunjungi cabang kanan
 Cetak isi simpul yang dikunjungi (simpul akar)
Sehingga output menghasilkan keluaran di layar :

Cara void PrintTreeLevelOrder:

Urutan pada LevelOrder yaitu melakukan kunjungan berdasarkan nilai/level depth yang
terendah sampai yang tertinggi pada depth 0 yaitu A akar, kemudian depth 1 yaitu B C D,
lalu depth 2 yaitu E F G H I J dan depth 3 yaitu K L M.
Sehingga output menghasilkan keluaran di layer :

Cara kerja void delChild (Penghapusan PreOrder)

Penghapusan pada preorder dilakukan berdasarkan kunjungan pada simpul anak yang
terakhir di kunjungi yaitu anak (J) = K L M.
Sehingga output menghasilkan keluaran di layar :

Fungsi yang digunakan pada program di atas :
1.

void makeTree
Inisialisasi sebuah tree, dengan mengisikan data ke simpul root, serta menetapkan
bahwa simpul root tidak memiliki sibling dan child.
2. void addChild
Mengalokasikan suatu simpul baru yang sudah kita isikan dengan data terhadap suatu
simpul yang menjadi parent-nya. Lalu ditetapkan juga bahwa simpul baru tersebut
tidak memiliki sibling dan child.
3. void delChild
Melakukan proses delete jika child suatu simpul diketahui memiliki child atau sibling
terlebih dahulu hingga simpul yang ingin kita hapus anaknya memang sudah 'aman'.
Cara lain yang biasa dilakukan adalah kita langsung saja set bahwa childnya null.
4. simpul *findSimpul
Menelusuri setiap simpul hingga dapat ditentukan ditemukan atau tidak simpul dengan
informasi tertentu yang sedang dicari. Dan jangan lupa untuk me-return simpul
tersebut agar bisa digunakan untuk proses lainnya.
5. void printTreePreOrder
Menampilkan simpul pohon ke Output secara Preorder
6. void printTreePostOrder
Menampilkan simpul pohon ke Output secara Postorder
7. void printTreeLevelOrderNext
Menampilkan simpul pohon ke Output secara Levelorder if(root != NULL){simpul
*node = root->child; if(node != NULL){if(node->sibling == NULL)
8. void printTreeLevelOrder
Menampilkan simpul pohon ke Output secara Levelorder if(root != NULL){ printf("
%c ", root -> info);
9. void copyTree
Menyalin pohon biner yang satu dengan pohon biner yang lainnya.
10. int isEqual (fungsi Boolean)
Mengembalikan nilai TRUE jika dua buah pohon biner merupakan pohon biner yang
sama dan mengembalikan nilai FALSE jika dua buah pohon biner tidak sama.

BAB III
KESIMPULAN
Berdasarkan dari tugas praktikum yang telah saya kerjakan saya dapat mengambil
kesimpulan :
 Kunjungan pada pohon n-er merupakan salah satu operasi yang sering dilakukan pada
suatu pohon biner tepat satu kali. Operasi ini terbagi menjadi 3 bentuk :
1. Kunjungan secara Preorder
Mempunyai urutan :
 Cetak isi simpul yang dukunjungi (simpul akar)
 Kunjungi cabang kiri
 Kunjungi cabang kanan
2. Kunjungan secara Postorder
Mempunyai urutan :
 Kunjungi cabang kiri
 Kunjungi cabang kanan
 Cetak isi simpul yang dukunjungi (simpul akar)
3. Kunjungan secara Inorder
Mempunyai urutan :
 Kunjungi cabang kiri
 Cetak isi simpul yang dukunjungi (simpul akar)
 Kunjungi cabang kanan
 Pohon n-er adalah bentuk lain dari binary tree (pohon biner), namun keduanya masih
sama-sama tree, artinya keduanya memiliki fungsi yang sama dalam penggunaannya.
Misalnya digunakan untuk menyimpan data yang memiliki hubungan (relasi) berupa
turunan (dan sebagainya) dengan data lainnya, juga seringkali digunakan pada DCS
(decision support system).
 Perbedaan Binary Tree dengan Pohon n-er adalah jika binary tree setiap simpulnya
(node) hanya diizinkan untuk memiliki maksimal 2 child, namun pada pohon n-er
sebuah simpul diizinkan memiliki n buah anak, dengan n lebih besar atau sama
dengan nol.