Project java part 2

Setelah kita mempersiapkan apa yang perlu di persiapkan pada Project java part 1. Kali ini masuk ke kodingan dari project yang akan dibuat. Postingan kali ini penulis share kodenya meskipun ada warning yang didapat namun tidak berpengaruh terhadap hasil dari project. Kode dibawah adalah kode  untuk struktur data tree, namun belum untuk tampilan desktop karena kode untuk struktur tree cukup panjang. Pada kode juga terdapat dokumentasi yang bisa membantu untuk memahami kode ini. Garis besarnya struktur tree bisa melakukan insert, search dan delete, sedangkan lainnya hanya tambahan untuk informasi pada tree.

Nah, bagaimana menggunakan kode dibawah ? Cukup simpel lho !. Buatlah file project pada IDE eclipse atau Klik File > new > Java Project, akan muncul suatu jendela, cukup isikan nama project dan klik finish. Akan muncul file project yang dibuat tadi di tab kiri eclipse. Buka file project tersebut, pada folder src klik kanan > new > package dan klik finish setelah memasukkan nama package pada jendela yang muncul. Selanjutnya adalah membuat class, klik kanan pada package yang dibuat tadi pilih new dan pilih class, perlu diperhatikan disini nama class yang dimasukka haruslah StructTree ,berbeda dengan pemberian nama project dan nama package, untuk menggunakan kode dibawah haruslah menggunakan nama class yang ada pada kode. Klik finish dan paste kode dibawah kedalam class yang baru saja dibuat. Nah class StructTree siap untuk digunakan, selanjutnya adalah membuat interface dari project tersebut yang akan dijelaskan pada postingan berikutnya.

import java.util.*;

class Node{
    int data;
    Node left;
    Node right;
    Node(int x){
        this.data = x;
    }
}

class StructTree{
    Node root;

    /**
     * Mengecek apakah tree masih kosong
     **/
    boolean isEmpty(){
        return (root == null);
    }
   
    boolean isHaveChild(Node localRoot){
        if(localRoot.left!=null || localRoot.right!=null){
            return true;
        }
        else{
            return false;
        }
    }
    /**
     * Memasukkan suatu nilai ke dalam tree.
     * Jika nilai tersebut lebih kecil dari nilai node, maka bergerak ke kiri terus
     * hingga menjadi child, begitu juga sebaliknya.
     **/
    void insert(int input){
        Node temp = new Node(input);
        if (isEmpty())
            root = temp;
        else {
            Node cursor = root,
                 parent = null;
            while (cursor != null){
                parent = cursor;
                if (input < cursor.data)
                    cursor = cursor.left;
                else
                    cursor = cursor.right;
            }
            /**
             * Menambahkan Node baru pada kiri/kanan Node parent bergantung
             * pada nilai input dan nilai yang disimpan Node parent
             */
            if (input < parent.data){
                parent.left = temp;
                return;
            }
            else {
                parent.right = temp;
                return;
            }
        }
    }
    /**
     * Mencari suatu nilai dalam tree berdasarkan prinsip :
     * Selama belum menemukan nilai yang sama,
     * Jika nilai yang dicari lebih kecil dari nilai yang disimpan dalam Node
     * maka bergerak ke left Child begitu juga sebaliknya.
     **/
    Node find(int key){
        Node cursor = root;
        while (cursor != null){
            if (cursor.data == key)
                return cursor;
            else if (key < cursor.data)
                cursor = cursor.left;
            else
                cursor = cursor.right;
        }
        return null;
    }
   
    Node minValue(Node localRoot) {
        if (localRoot.left == null)
              return localRoot;
        else
              return minValue(localRoot.left);
    }
    Node maxValue(Node localRoot) {
        if (localRoot.right == null)
              return localRoot;
        else
              return maxValue(localRoot.right);
    }
   
    boolean isLeftChild = true;
   
    boolean hapus(Node localRoot, int key){
        Node current = localRoot;
        Node parent = localRoot;
       
        while (current.data != key) {
            parent = current;
            if (key < current.data) {
                isLeftChild = true;
                current = current.left;
            } else {
                isLeftChild = false;
                current = current.right;
            }
            if (current == null) {
                return false;
            }
        }
        if(current.data == key){
            if(current.left != null){
                int x = current.data =  maxValue(current.left).data;
                hapus(current.left,x);
            }
            else if(current.right != null){
                int x = current.data = minValue(current.right).data;
                hapus(current.right,x);
            }
            else if(current.left==null && current.right==null){
                if(parent != current){
                    if(isLeftChild){
                        parent.left = null;
                    }
                    else{
                        parent.right = null;
                    }
                }
                else{
                    if(isLeftChild){
                        Node s = find(current.data);
                        if(s.left != null){
                            find(maxValue(s.left).data).left = null;
                        }
                        else{
                            find(minValue(s.right).data).right = null;
                        }
                    }
                    else{
                        Node s = find(current.data);
                        if(s.left != null){
                            find(maxValue(s.left).data).left = null;
                        }
                        else{
                            find(minValue(s.right).data).right = null;
                        }
                    }
                }
            }
            return true;
        }
        else{
            return false;
        }
    }
   
    Node getParent(Node localRoot,int x){
        Node current = localRoot;
        Node parent = localRoot;
        while (current != null){
            if (current.data == x)
                return parent;
            else if (x < current.data){
                current = current.left;
            }
            else{
                parent = current;
                current = current.right;
            }
        }
        return null;
    }
   
    int nbDaun(Node localRoot){
        Node current = localRoot;
        if(current == null){
            return 0;
        }
        else{
            if((current.left==null) && (current.right==null)){
                return 1;
            }
            else{
                return nbDaun(current.left) + nbDaun(current.right);
            }
        }
    } 
   
    int level(Node localRoot){
        int u,v;
       
        if (localRoot == null){
            return 0;
        }
        u = level(localRoot.left);
        v = level(localRoot.right);
        if (u > v)
                return u+1;
        else return v+1;
    }
   
    void print() {
        Stack s = new Stack();
        s.push(root);
        int nBlanks = 32;
        boolean isRowEmpty = false;
        while (isRowEmpty == false) {
            Stack localStack = new Stack();
            isRowEmpty = true;
            for (int j = 0; j < nBlanks; j++) {
                System.out.print(' ');
            }
            while (!s.isEmpty()) {
                Node temp = (Node) s.pop();
                if (temp != null) {
                    System.out.print(temp.data);
                    localStack.push(temp.left);
                    localStack.push(temp.right);
                    if (temp.left != null || temp.right != null) {
                        isRowEmpty = false;
                    }
                } else {
                    System.out.print("  ");
                    localStack.push(null);
                    localStack.push(null);
                }
                for (int j = 0; j < nBlanks * 2 - 2; j++) {
                    System.out.print(' ');
                }
            }
            System.out.println();
            nBlanks /= 2;
            while (!localStack.isEmpty()) {
                s.push(localStack.pop());
            }
        }
    }
}