"Ordenamiento Arbol binario"

Un Árbol Binario es un conjunto de finito de Elementos, de nombre Nodos de forma que:
El Árbol Binario es Vació si no tiene ningún elemento en el.
El Árbol Binario contiene un Nodo Raíz y los dos que parten de él, llamados Nodo Izquierdo y Nodo Derecho.

Los Árboles tiene 3 Recorridos Diferentes los cuales son:
Pre-Orden
In-Orden
Post-Orden
Pre-Orden

Definición:

El Recorrido “Pre-Orden” lo recorre de la siguiente manera, viaje a través del Árbol Binario desplegando el Contenido en la Raíz, después viaje a través del Nodo Izquierdo y después a través del Nodo Derecho.

Detalle:
Temp toma el Valor de la Raíz y compara si el Árbol tiene algún Elemento, de otra manera Desplegara “Árbol Vació…” y terminara el método. Si el Árbol tiene elementos dentro de él, lo recorrerá y viajara a través de los Arreglos Izq y Der para determinar que valor meter en la Pila y en Temp para de esta manera imprimir el siguiente Elemento correspondiente.

El Recorrido “In-Orden” lo recorre de la siguiente manera, viaje a través del Árbol Binario desplegando el Contenido en el Nodo Izquierdo después la Raíz y finalmente viaja a través del Nodo Derecho.

Detalle:
Temp toma el Valor de la Raíz y compara si el Árbol tiene algún Elemento, de otra manera Desplegara “Árbol Vació…” y terminara el método. Si el Árbol tiene elementos dentro de él, lo recorrerá y viajara a través de los Arreglos Izq y Der para determinar que valor meter en la Pila y en Temp para de esta manera imprimir el siguiente Elemento correspondiente.



class NodoArbol{
NodoArbol li,ld;
int dato;

public NodoArbol(int d){
dato=d;
li=ld=null;
}

public synchronized void insertar(int d){

if(ddato){
if(ld==null){
ld=new NodoArbol(d);
}
else{
ld.insertar(d);
}
}

}//fin insertar

public int retornadato(){
return(dato);
}//end retornadato

}

public class Arbol {

private NodoArbol raiz;

public Arbol() {
raiz=null;
}
public NodoArbol retornaraiz(){
return(raiz);
}


public synchronized void insertarNodo(int d){
if(raiz==null){
raiz=new NodoArbol(d);
//primero=raiz;
}
else{
raiz.insertar(d);
}
}//fin insertarNodo

public synchronized String preorden(){
String pre=ayudantepreorden(raiz);
return(pre);
}

private String ayudantepreorden(NodoArbol nodo){
String cadena=new String();
if(nodo!=null){
//return;

//System.out.print(nodo.dato+" ");
cadena=cadena+String.valueOf(nodo.dato+" ");
cadena=cadena+ayudantepreorden(nodo.li);
cadena=cadena+ayudantepreorden(nodo.ld);
}
else{
cadena="";
}
return(cadena);
}

public synchronized String inorden(){
String inor=ayudanteinorden(raiz);
return(inor);
}

private String ayudanteinorden(NodoArbol nodo){
String cadena=new String();
if(nodo!=null){
// return;

cadena=cadena+ayudanteinorden(nodo.li);
cadena=cadena+nodo.dato+" ";
cadena=cadena+ayudanteinorden(nodo.ld);
}
else{cadena="";}
return(cadena);
}

public synchronized String posorden(){
String pos=ayudanteposorden(raiz);
return(pos);
}

private String ayudanteposorden(NodoArbol nodo){
String cadena=new String();
if(nodo!=null){



cadena=cadena+ayudanteposorden(nodo.li);
cadena=cadena+ayudanteposorden(nodo.ld);
cadena=cadena+nodo.dato+" ";
}
else{cadena="";}
return(cadena);
}

public synchronized int altura(NodoArbol R){
NodoArbol p=R;
int altizq=p.li==null ? 1:1+altura(p.li);
int altder=p.ld==null ? 1:1+altura(p.ld);
return(Math.max(altizq,altder));
}//end altura

public synchronized int hojas(NodoArbol R){
NodoArbol p=R;
int hojas=0;
if(p.li==null & p.ld==null){
hojas=1;
}
else{
if(p.li!=null){
hojas=hojas+hojas(p.li);
}
if(p.ld!=null){
hojas=hojas+hojas(p.ld);
}
}
return(hojas);
}//end hojas

public synchronized String ancestros(NodoArbol R,int d){
NodoArbol p=R;

String h=new String();

if (p.dato==d){
return(String.valueOf(" --> "+d));
}//end if

if (d>p.dato){
h=h+" --> "+p.dato+ancestros(p.ld,d);
}
else{
h=h+" --> "+p.dato+ancestros(p.li,d);
}
return(h);
}

}