Árbol Binario 

En ciencias de la computación, un árbol binario es una estructura de datos en la cual cada nodo siempre tiene un hijo izquierdo y un hijo derecho. No pueden tener más de dos hijos (de ahí el nombre "binario"). Si algún hijo tiene como referencia a null, es decir que no almacena ningún dato, entonces este es llamado un nodo externo. En el caso contrario el hijo es llamado un nodo interno. Usos comunes de los árboles binarios son los árboles binarios de búsqueda, los montículos binarios y Codificación de Huffman.

Tipos de árboles binarios

Un árbol binario es un árbol con raíz en el que cada nodo tiene como máximo dos hijos.

1. Un árbol binario lleno es un árbol en el que cada nodo tiene cero o dos hijos.

1. Un árbol binario perfecto es un árbol binario lleno en el que todas las hojas (vértices con cero hijos) están a la misma profundidad (distancia desde la raíz, también llamada altura).

1. A veces un árbol binario perfecto es denominado árbol binario completo. Otros definen un árbol binario completo como un árbol binario lleno en el que todas las hojas están a profundidad n o n-1, para alguna n.

Programa de Árbol binario JavaSe implementara un programa que solicite una cantidad de datos a ingresar y posteriormente los ordenra como un árbol binario.

1. Solicitara la cantidad de datos a ingresar

1. solicitar ingresar datos numéricos hasta completar la cantidad indicada en el punto uno

1. desplegara los datos ordenados en orden

1. Indicara cuanto son la cantidad de nodos 

1. Indicara cuantos nodos son del tipo hoja

1. Desplegara los datos indicando su nivel

1. Desplegara la altura del árbol

1. Desplegara el mayor valor del árbol

1. eliminara el menor valor

Actividades implementadas



Salida del programa


run:
Ingrese el numero de Datos a capturar: 7
Ingrese Dato Solo Numerico 1:  
11
Ingrese Dato Solo Numerico 2:  
33
Ingrese Dato Solo Numerico 3:  
55
Ingrese Dato Solo Numerico 4:  
6
Ingrese Dato Solo Numerico 5:  

8
Ingrese Dato Solo Numerico 6:  
00
Ingrese Dato Solo Numerico 7:  
1
Impresion entreorden: 
0 1 6 8 11 33 55 
Cantidad de nodos del árbol:7
Cantidad de nodos hoja:3
Impresion en entre orden junto al nivel del nodo.
0 (3) - 1 (4) - 6 (2) - 8 (3) - 11 (1) - 33 (2) - 55 (3) - 
Artura del arbol:4
Mayor valor del árbol:55
Luego de borrar el menor:
1 6 8 11 33 55 


clases 

main 

package cl.arbol;

public class main {

    public static void main (String [] ar)
    {
        ArbolBinarioOrdenado abo = new ArbolBinarioOrdenado ();
        
        java.util.Scanner leer=new java.util.Scanner(System.in);
                int z;
        System.out.print("Ingrese el numero de Datos a capturar: ");
        z=leer.nextInt();
        for(int i=1; i<=z;i++){
        int m;
        System.out.println("Ingrese Dato Solo Numerico "+i+":  ");m=leer.nextInt();
        abo.insertar(m);
        }
    
        
        System.out.println ("Impresion entreorden: ");
        abo.imprimirEntre ();
        System.out.println ("Cantidad de nodos del árbol:"+abo.cantidad());
        System.out.println ("Cantidad de nodos hoja:"+abo.cantidadnodosHoja());          
        System.out.println ("Impresion en entre orden junto al nivel del nodo.");
        abo.imprimirEntreConNivel();
        System.out.print ("Artura del arbol:");
        System.out.println(abo.retornarAltura());        
        abo.mayorValorl();
        abo.borrarMenor();
        System.out.println("Luego de borrar el menor:");
        abo.imprimirEntre ();
    }

}

ArbolBinarioOrdenado 


package cl.arbol;

class ArbolBinarioOrdenado {
  
     nodo raiz;
private int cant;
private int altura;
//constructor
     public ArbolBinarioOrdenado()
     {
         raiz=null;
     }
     
     private void imprimirPre (nodo reco)
     {
         if (reco != null)
         {
             System.out.print(reco.info + " ");
             imprimirPre (reco.izq);
             imprimirPre (reco.der);
         }
     }

     public void imprimirPre ()
     {
         imprimirPre (raiz);
         System.out.println();
     }

     private void imprimirEntre (nodo reco)
     {
         if (reco != null)
         {    
             imprimirEntre (reco.izq);
             System.out.print(reco.info + " ");
             imprimirEntre (reco.der);
         }
     }

  
     private void imprimirPost (nodo reco)
     {
         if (reco != null)
         {
             imprimirPost (reco.izq);
             imprimirPost (reco.der);
             System.out.print(reco.info + " ");
         }
     }


     public void imprimirPost ()
     {
         imprimirPost (raiz);
         System.out.println();
     }

     
     
     public void insertar (int info) {
         if (!existe(info)) {
             nodo nuevo;
             nuevo = new nodo ();
             nuevo.info = info;
             nuevo.izq = null;
               nuevo.der = null;
             if (raiz == null)
                 raiz = nuevo;
             else {
                 nodo anterior = null, reco;
                 reco = raiz;
                 while (reco != null)  {
                     anterior = reco;
                     if (info < reco.info)
                         reco = reco.izq;
                     else
                         reco = reco.der;
                 }
                 if (info < anterior.info)
                     anterior.izq = nuevo;
                 else
                     anterior.der = nuevo;
             }
         }    
     }

     public boolean existe(int info) {
         nodo reco=raiz;
         while (reco!=null) {
             if (info==reco.info)
                 return true;
             else
                 if (info>reco.info)
                     reco=reco.der;
                 else
                     reco=reco.izq;
         }
         return false;
     }

     public void imprimirEntre () {
         imprimirEntre (raiz);
         System.out.println();
     }

     
     private void cantidad(nodo reco) {
         if (reco!=null) {
             cant++;
             cantidad(reco.izq);
             cantidad(reco.der);
         }
     }
     
     public int cantidad() {
         cant = 0;
         cantidad(raiz);
         return cant;
     }

     private void cantidadnodosHoja(nodo reco) {
         if (reco!=null) {
             if (reco.izq==null && reco.der==null)
                 cant++;
             cantidadnodosHoja(reco.izq);
             cantidadnodosHoja(reco.der);
         }
     }
     
     public int cantidadnodosHoja() {
         cant=0;
         cantidadnodosHoja(raiz);
         return cant;
     }

     private void imprimirEntreConNivel (nodo reco,int nivel)  {
         if (reco != null) {    
             imprimirEntreConNivel (reco.izq,nivel+1);
             System.out.print(reco.info + " ("+nivel+") - ");
             imprimirEntreConNivel (reco.der,nivel+1);
         }
     }

     public void imprimirEntreConNivel () {
         imprimirEntreConNivel (raiz,1);
         System.out.println();
     }
     
     private void retornarAltura (nodo reco,int nivel)    {
         if (reco != null) {    
             retornarAltura (reco.izq,nivel+1);
             if (nivel>altura)
                 altura=nivel;
             retornarAltura (reco.der,nivel+1);
         }
     }

     public  int retornarAltura () {
         altura=0;
         retornarAltura (raiz,1);
         return altura;
     }
     
     public void mayorValorl() {
         if (raiz!=null) {
             nodo reco=raiz;
             while (reco.der!=null)
                 reco=reco.der;
             System.out.println("Mayor valor del árbol:"+reco.info);
         }
     }
     
     public void borrarMenor() {
         if (raiz!=null) {
             if (raiz.izq==null)
                 raiz=raiz.der;
             else {
                 nodo atras=raiz;
                 nodo reco=raiz.izq;
                 while (reco.izq!=null) {
                     atras=reco;
                     reco=reco.izq;
                 }
                 atras.izq=reco.der;
             }                  
         }
     }      
}

nodo


package cl.arbol;


public  class nodo
{
    int info;
    nodo izq, der;
  }

Refrencias 

http://es.wikipedia.org/wiki/%C3%81rbol_binario

Juan Carlos Delgado