Tarea Estructuras de Datos Arbol BB bien documentado

Arbol.java

/**
 *
 * @author Godie007
 */
public class Arbol {

    private NodoArbol raiz;

    //contruir un arbol vacio
    public Arbol() {
        raiz = null;
    }

    //insertar un nuevo nodo en el arbol de busqueda binaria
    public synchronized void insertarNodo(int valorInsertar) {
        if (raiz == null) {
            raiz = new NodoArbol(valorInsertar); //crea nodo raiz
        } else {
            raiz.insertar(valorInsertar); // llama al metodo insertar
        }
    }

    //--------------- EMPESAR EL RECORRIDO EN PREORDEN-----------------------
    public synchronized void recorridoPreorden() {
        ayudantePreorden(raiz);
    }
    //metodo recursivo para recorrido en preorden

    private void ayudantePreorden(NodoArbol nodo) {
        if (nodo == null) {
            return;
        }

        System.out.print(nodo.datos + " "); // mostrar datos del nodo
        ayudantePreorden(nodo.nodoizquierdo); //recorre subarbol izquierdo
        ayudantePreorden(nodo.nododerecho); //recorre subarbol derecho
    }

    //--------------EMPEZAR RECORRIDO INORDEN-----------------------------------
    public synchronized void recorridoInorden() {
        ayudanteInorden(raiz);
    }

    // metodo recursivo para recorrido inorden
    private void ayudanteInorden(NodoArbol nodo) {
        if (nodo == null) {
            return;
        }

        ayudanteInorden(nodo.nodoizquierdo);
        System.out.print(nodo.datos + " ");
        ayudanteInorden(nodo.nododerecho);
    }

    //-----------------------------EMPEZAR RECORRIDO POSORDEN---------------------------------
    public synchronized void recorridoPosorden() {
        ayudantePosorden(raiz);
    }

    //metodo recursivo para recorrido posorden
    private void ayudantePosorden(NodoArbol nodo) {
        if (nodo == null) {
            return;
        }

        ayudantePosorden(nodo.nodoizquierdo);
        ayudantePosorden(nodo.nododerecho);
        System.out.print(nodo.datos + " ");
    }
    //-----------------------------CONTAR RAMAS---------------------------------

    public synchronized void contarRamas() {
        System.out.println(contarRamas(raiz));
    }
    //metodo para contar el numero de ramas de un arbol
    private int contador;

    private int contarRamas(NodoArbol n) {
        if (n != null) {
            int izq = contarRamas(n.nodoizquierdo);
            int der = contarRamas(n.nododerecho);
            contador = izq + der + 1;
        } else {
            return 0;
        }

        return contador;
    }
    //-----------------------------CONTAR AlTURA---------------------------------

    public synchronized void calcularAltura() {
        System.out.println(calcularAltura(raiz));
    }
    //metod para calcular la altura del arbol

    private int calcularAltura(NodoArbol n) {
        if (n == null) {
            return 0;
        }
        int n1 = calcularAltura(n.nodoizquierdo);
        int n2 = calcularAltura(n.nodoizquierdo);
        if (n1 > n2) {
            return n1 + 1;
        }
        return n2 + 1;
    }
    //-----------------------------Buscar---------------------------------

    public synchronized void buscar(int dato) {
        System.out.println(buscar(raiz, dato));
    }
    // metodo privado para buscar un nodo en el ABB

    private boolean buscar(NodoArbol r, int x) {
        if (r == null) {
            return (false);
        }
        int compara = ((Comparable) r.datos).compareTo(x);
        if (compara > 0) {
            return (buscar(r.nodoizquierdo, x));
        } else if (compara < 0) {
            return (buscar(r.nododerecho, x));
        } else {
            return (true);
        }
    }

    //-----------------------------Borrar---------------------------------
    public synchronized void borrar(int dato) {
        raiz = borrar(raiz, dato);
        System.out.println("Fue eliminado exitosamente");
    }

    /**
     * Borra un elmento del árbol binario de búsqueda, manteniendo su propieda
     * de orden, para esto se busca el menor de los derechos y lo intercambia
     * por el dato que desea borrar. La idea del algoritmo es que el dato a
     * borrar se coloque en una hoja o en un nodo que no tenga una de sus ramas.
     *
     * @param x dato que se desea borrar
     * @return el dato borrado o null si no lo encontro
     */
    private NodoArbol borrar(NodoArbol r, int x) {
        if (r == null) {
            return null;//<--Dato no encontrado		
        }
        int compara = ((Comparable) r.datos).compareTo(x);
        if (compara > 0) {
            r.nodoizquierdo = (borrar(r.nodoizquierdo, x));
        } else if (compara < 0) {
            r.nododerecho = (borrar(r.nododerecho, x));
        } else {
//            System.out.println("Encontro el dato:" + x);
            if (r.nodoizquierdo != null && r.nododerecho != null) {
                /*
                 *	Buscar el menor de los derechos y lo intercambia por el dato
                 *	que desea borrar. La idea del algoritmo es que el dato a borrar 
                 *	se coloque en una hoja o en un nodo que no tenga una de sus ramas.
                 **/
                NodoArbol cambiar = buscarMin(r.nododerecho);
                int aux = cambiar.datos;
                cambiar.datos = r.datos;
                r.datos = aux;
                r.nododerecho = (borrar(r.nododerecho, x));
                System.out.println("2 ramas");
            } else {
                r = (r.nodoizquierdo != null) ? r.nodoizquierdo : r.nododerecho;
//                System.out.println("Entro cuando le faltan ramas ");
            }
        }
        return r;
    }
    /*
     *  Busca el menor dato del árbol. El menor dato
     *  del árbol se encuentra en el nodo mas izquierdo.
     **/

    @SuppressWarnings("empty-statement")
    private NodoArbol buscarMin(NodoArbol r) {
        for (; r.nodoizquierdo != null; r = r.nododerecho);
        return (r);
    }
    //-----------------------------modificar---------------------------------

    public synchronized void modificar(int dato, int mod) {
        raiz = modificar(dato, mod, raiz);
        System.out.println("Modificado Exitosamente");
    }

    private NodoArbol modificar(int llave, int val, NodoArbol nodo) {
        if (nodo == null) {
            return null;
        }
        if (llave == nodo.datos) {
            nodo.datos = val;
        } else if (llave < nodo.datos) {
            nodo.nodoizquierdo = modificar(llave, val, nodo.nodoizquierdo);
        } else {
            nodo.nododerecho = modificar(llave, val, nodo.nododerecho);
        }
        return nodo;
    }
}

ensayos.java

/**
 *
 * @author Godie007
 */
public class PruebaArbol {

    public static void main(String args[]) {
        Arbol arbol = new Arbol();
        int valor;

        arbol.insertarNodo(5);
        arbol.insertarNodo(8);
        arbol.insertarNodo(0);
        arbol.insertarNodo(2);
        arbol.insertarNodo(-1);
        
        

        System.out.println("Recorrido preorden");
        arbol.recorridoPreorden();

        System.out.println("\nRecorrido inorden");
        arbol.recorridoInorden();

        System.out.println("\nRecorrido posorden");
        arbol.recorridoPosorden();

        System.out.println("\ncontar numero de ramas");
        arbol.contarRamas();

        System.out.println("altura del Arbol");
        arbol.calcularAltura();
        
        System.out.println("Buscar: 2");
        arbol.buscar(2);
        
        System.out.println("Borrar: 2");
        arbol.borrar(2);
        arbol.recorridoInorden();
        
        System.out.println("\n modificar el 0 por 7");
        arbol.modificar(0, 7);
        arbol.recorridoInorden();
    }
}

NodoArbol.java

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author Godie007
 */
public class NodoArbol {
    //miembros de acceso
	NodoArbol nodoizquierdo;
	int datos;
	NodoArbol nododerecho;

	//iniciar dato y hacer de este nodo un nodo hoja
	public NodoArbol(int datosNodo)
	{
		datos = datosNodo;
		nodoizquierdo = nododerecho = null; //el nodo no tiene hijos
	}


	//buscar punto de insercion  e insertar nodo nuevo
	public synchronized void insertar(int valorInsertar)
	{
		//insertar en subarbol izquierdo
		if (valorInsertar < datos){

			//inserta nuevo nodoarbol
			if (nodoizquierdo == null)
				nodoizquierdo = new NodoArbol(valorInsertar);
			else //continua recorriendo subarbol izquierdo
				nodoizquierdo.insertar(valorInsertar);
		}

		//insertar nodo derecho
		else if(valorInsertar > datos){

		//insertar nuevo nodoarbol
		if (nododerecho == null)
			nododerecho = new NodoArbol(valorInsertar);
		else //continua recorriendo subarbol derecho
			nododerecho.insertar(valorInsertar);
		}
	} //fin del metodo insertar


}