ALGORITMA & STRUKTUR DATA BAB 9 : ADT BINARY TREE

Laporan Praktikum Algoritma & Struktur Data Bab 9 Fakultas Ilmu Komputer Universitas Brawijaya 2017/2018

Soal :

      1. Tambahkan method untuk menghitung jumlah simpul, kedalaman, dan daun pada Binary Tree

     2. Dari program di atas buatlah program untuk menampilkan hasil dari preorder, inorder, dan postorder dengan bentuk angka maupun urut abjad. Sehingga akan didapatkan hasil:

Contoh input pertama: 1154 11 200 150 1 55

            Tampilan  secara PreOrder : 1154 11 1 200 150 55

            Tampilan secara InOrder : 1 11 55 150 200 1154

            Tampilan secara PostOrder : 1 55 150 200 11 1154

Contoh input kedua: N B A D

            Tampilan secara PreOrder : N B A D

            Tampilan secara InOrder : A B D N

            Tampilan secara PostOrder : A D B N

Source code :
Soal no.1

package asdmodul4;

import static java.lang.Integer.max;
import java.util.Random;

class Node {

    int data;
    Node nodeKiri;
    Node nodeKanan;

    public Node(int dt) {
        data = dt;
        nodeKiri = nodeKanan = null;
    }

    public void sisipDt(int dtSisip) {
        if (dtSisip < data) {
            if (nodeKiri == null) {
                nodeKiri = new Node(dtSisip);
            } else {
                nodeKiri.sisipDt(dtSisip);
            }
        } else if (dtSisip > data) {
            if (nodeKanan == null) {
                nodeKanan = new Node(dtSisip);
            } else {
                nodeKanan.sisipDt(dtSisip);
            }
        }
    }
}

public class ASDModul4 {

    private Node root;

    public ASDModul4() {
        root = null;
    }

    public void sisipDtNode(int dtSisip) {
        if (root == null) {
            root = new Node(dtSisip);
        } else {
            root.sisipDt(dtSisip);
        }
    }

    public void preorderTraversal() {
        preorder(root);
    }

    private void preorder(Node node) {
        if (node == null) {
            return;
        }
        System.out.printf("%d ", node.data);
        preorder(node.nodeKiri);
        preorder(node.nodeKanan);
    }

    public void inorderTraversal() {
        inorder(root);
    }

    private void inorder(Node node) {
        if (node == null) {
            return;
        }
        inorder(node.nodeKiri);
        System.out.printf("%d ", node.data);
        inorder(node.nodeKanan);
    }

    public void postorderTraversal() {
        postorder(root);
    }

    private void postorder(Node node) {
        if (node == null) {
            return;
        }
        postorder(node.nodeKiri);
        postorder(node.nodeKanan);
        System.out.printf("%d ", node.data);
    }

    public int depth(Node nd) {
        if (nd == null) {
            return -1;
        }
        int s = depth(nd.nodeKiri);
        int z = depth(nd.nodeKanan);
        if (s > z) {
            return s + 1;
        } else {
            return z + 1;
        }
    }

    public int twist(Node nd) {
        if (nd == null) {
            return 0;
        }
        return twist(nd.nodeKiri) + twist(nd.nodeKanan)+1;
    }

    public int leaf(Node nd) {
        if (nd==null){
            return 0;
        }
        else if(nd.nodeKiri==null && nd.nodeKanan==null){
            return 1;
        } else {
            return(leaf(nd.nodeKiri)+leaf(nd.nodeKanan));
        }
    }

    public static void main(String args[]) {
        ASDModul4 Tree = new ASDModul4();
        int nilai = 0;
        Random randomNumber = new Random();
        Node nd = new Node(nilai);
        System.out.println("sisip nilai data berikut : ");
        Tree.sisipDtNode(1154);
        Tree.sisipDtNode(11);        
        Tree.sisipDtNode(200);
        Tree.sisipDtNode(150);
        Tree.sisipDtNode(1);
        Tree.sisipDtNode(55);
        System.out.println("\n\nPreorder traversal");
        Tree.preorderTraversal();
        System.out.println("\n\nInorder traversal");
        Tree.inorderTraversal();
        System.out.println("\n\nPostorder traversal");
        Tree.postorderTraversal();
        System.out.println();
        System.out.print("\nKedalaman = "+Tree.depth(Tree.root));
        System.out.print("\nSimpul = "+Tree.twist(Tree.root));
        System.out.print("\nJumlah Daun = "+Tree.leaf(Tree.root));
        
    }
}

Soal no.2

package asdmodul4;

import java.util.Random;

class NodeAl {

    int data;
    NodeAl nodeKiri;
    NodeAl nodeKanan;

    public NodeAl(int dt) {
        data = dt;
        nodeKiri = nodeKanan = null;
    }

    public void sisipDt(int dtSisip) {
        if (dtSisip < data) {
            if (nodeKiri == null) {
                nodeKiri = new NodeAl(dtSisip);
            } else {
                nodeKiri.sisipDt(dtSisip);
            }
        } else if (dtSisip > data) {
            if (nodeKanan == null) {
                nodeKanan = new NodeAl(dtSisip);
            } else {
                nodeKanan.sisipDt(dtSisip);
            }
        }
    }
}

public class Alphabet {

    private NodeAl root;
    private int a, tot;

    public Alphabet() {
        root = null;
    }

    public void sisipDtNode(int dtSisip) {
        if (root == null) {
            root = new NodeAl(dtSisip);
        } else {
            root.sisipDt(dtSisip);
        }
    }

    public void preorderTraversal() {
        preorder(root);
    }

    private void preorder(NodeAl node) {
        if (node == null) {
            return;
        }
        if (a == 1) {
            System.out.print(" " + (char) node.data);
        } else {
            System.out.printf("%d ", node.data);
        }
        preorder(node.nodeKiri);
        preorder(node.nodeKanan);
    }

    public void inorderTraversal() {
        inorder(root);
    }

    private void inorder(NodeAl node) {
        if (node == null) {
            return;
        }
        inorder(node.nodeKiri);
        if (a == 1) {
            System.out.print(" " + (char) node.data);
        } else {
            System.out.printf("%d ", node.data);
        }
        inorder(node.nodeKanan);
    }

    public void postorderTraversal() {
        postorder(root);
    }

    private void postorder(NodeAl node) {
        if (node == null) {
            return;
        }
        postorder(node.nodeKiri);
        postorder(node.nodeKanan);
        if (a == 1) {
            System.out.print(" " + (char) node.data);
        } else {
            System.out.printf("%d ", node.data);
        }
    }

    public int alpha(char h) {
        a = 1;
        return (int) h;
    }

    public static void main(String args[]) {
        Alphabet al = new Alphabet();
        al.sisipDtNode(al.alpha('N'));
        al.sisipDtNode(al.alpha('B'));
        al.sisipDtNode(al.alpha('A'));
        al.sisipDtNode(al.alpha('D'));
        System.out.print("\nPreorder:\t");
        al.preorderTraversal();
        System.out.print("\nInorder :\t");
        al.inorderTraversal();
        System.out.print("\nPostorder :\t");
        al.postorderTraversal();
    }
}

Download the file here