TALLER DE ESTRUCTURA DE DATOS

Realice la prueba del siguiente programa y documente cada línea de

instrucción y la prueba que realiza.

Arboles Java: Recorrido en InOrden - PreOrden - PostOrden

ARBOLES BINARIOS

Creación de un Nodo

public class Nodo // Clase Nodo

{
private int dato;
private Nodo izq;
private Nodo der;

public Nodo(int dato)

{
this.dato = dato;
izq = null;
der = null;
}

public Nodo getIzq()

{
return izq;
}

public void setIzq(Nodo izq)

{
this.izq = izq;
}

public Nodo getDer()

{
return der;
}

public void setDer(Nodo der)

{
this.der = der;
}

public int getDato()

{
TALLER DE ESTRUCTURA DE DATOS

return dato;
}

public void setDato(int dato)

{
this.dato = dato;
}
}

Creación de un Árbol Binario

Métodos de un Árbol Binario:

public class Arbol // CLASE ARBOL

{
private Nodo raiz;

public Arbol()
{
raiz = null;
}

public void cargar() // METODO CARGAR ARBOL

{
adicionarNodo(raiz, new Nodo (10));
adicionarNodo(raiz, new Nodo (11));
adicionarNodo(raiz, new Nodo (15));
adicionarNodo(raiz, new Nodo (12));
adicionarNodo(raiz, new Nodo (16));
adicionarNodo(raiz, new Nodo (9));
adicionarNodo(raiz, new Nodo (3));
adicionarNodo(raiz, new Nodo (2));
adicionarNodo(raiz, new Nodo (5));
}

public boolean vacioArbol(Nodo a)//Metodo para saber si el arbol

esta completamente vacio
{
return (a == null);
}

public Nodo getRaiz() //procedimiento para obtener la raiz

TALLER DE ESTRUCTURA DE DATOS

{
return raiz;
}

public void setRaiz(Nodo raiz) // Agregar Raiz a el Arbol

{
this.raiz = raiz;
}

public Nodo getIzqArbol(Nodo a)//retorna el arbol izquierdo

{
if(a.getIzq() == null)
{
return null;
}
else
{
return a.getIzq();
}
}

public Nodo getDerArbol(Nodo a)//retorna el arbol derecho

{
if(a.getDer() == null)
{
return null;
}
else
{
return a.getDer();
}
}

public String adicionarNodo(Nodo a, Nodo n)/ /Agrega un nodo al arbol

Ordenado
{
if(vacioArbol(a))
{
raiz = n;
return "Elemento insertado correctamente.";
}
else
{
if(a.getDato() != n.getDato())
TALLER DE ESTRUCTURA DE DATOS

{
if(n.getDato() < a.getDato())
{
if (getIzqArbol(a) == null)
{
a.setIzq(n);
return "Elemento insertado correctamente.";
}
else
{
return adicionarNodo(getIzqArbol(a), n);
}
}
else if(n.getDato() > a.getDato())
{
if (getDerArbol(a) == null)
{
a.setDer(n);
return "Elemento insertado correctamente.";
}
else
{
return adicionarNodo(getDerArbol(a), n);
}
}
}
else
{
return "No se puede agregar el Elemento.";
}
}
return "";
}

public void preorden(Nodo a) //realiza el recorrido en preorden de

un arbol
{
if(!vacioArbol(a))
{
System.out.print(a.getDato()+ " ");
preorden(getIzqArbol(a));
preorden(getDerArbol(a));
}
}
TALLER DE ESTRUCTURA DE DATOS

public void inorden(Nodo a) //realiza el recorrido en inorden de

un arbol
{
if(!vacioArbol(a))
{
inorden(getIzqArbol(a));
System.out.print(a.getDato()+ " ");
inorden(getDerArbol(a));
}
}

public void postorden(Nodo a)//realiza el recorrido en postorden

de un arbol
{
if(!vacioArbol(a))
{
postorden(getIzqArbol(a));
postorden(getDerArbol(a));
System.out.print(a.getDato()+ " ");
}
}

public Nodo buscarNodo(Nodo a, int dato)//retorna

un nodo el cual
contiene un dato que se busca, si no lo encuentra retorna
null
{
if(a != null)
{
if(a.getDato() == dato)
{
return a;
}

else
{
if(dato > a.getDato())
{
return buscarNodo(a.getDer(), dato);
}
else
{
return buscarNodo(a.getIzq(), dato);
}
TALLER DE ESTRUCTURA DE DATOS

}
}
else
{
return null;
}
}

public boolean soloRaiz(Nodo nodo){ // METODO ELIMINAR

NODO DEL ARBOL
if(nodo.getDer()==null && nodo.getIzq()==null ){
nodo=null;
return true;
}
return false;
}
public Nodo EliminarNodo(Nodo nodo, int dato)
{
if(soloRaiz(nodo))
{
return null;
}

if (nodo == null){
System.out.println("No se encuentra el nodo.");
}
else if (dato < nodo.getDato()){
Nodo izq;
izq = EliminarNodo(nodo.getIzq(), dato);
nodo.setIzq(izq);
}
else if (dato > nodo.getDato()){
Nodo der;
der = EliminarNodo(nodo.getDer(), dato);
nodo.setDer(der);
}
else{
Nodo eliminar;
eliminar = nodo;

if(eliminar.getIzq() == null)
{
nodo = eliminar.getDer();
}
else if (eliminar.getDer() == null)
TALLER DE ESTRUCTURA DE DATOS

{
nodo = eliminar.getIzq();
}
else
{
eliminar = reemplazar(eliminar);
}
eliminar = null;
}
return nodo;
}

public Nodo reemplazar(Nodo nodo)

{
Nodo N1, N2;
N2 = nodo;
N1 = nodo.getIzq();

while(N1.getDer() != null)
{
N2 = N1;
N1 = N1.getDer();
}

nodo.setDato(N1.getDato());

if(N2 == nodo)
{
N2.setIzq(N1.getIzq());
}
else
{
N2.setDer(N1.getIzq());
}

return N1;
}
} // Fin Clase ARBOL