class CArbol

public class CArbol
{
/* *********************** Atributos
private Object aRaiz;
private CArbol aPrimerHijo;
private CArbol aSgteHermano;
********************* */
/* ***********************
Metodos
********************* */
/* ==================== Constructores ===================== */
/* ---------------------------------------------------------- */
protected CArbol()
{
aRaiz = null;
aPrimerHijo = null;
aSgteHermano = null;
}
/* ---------------------------------------------------------- */
protected CArbol( Object pRaiz)
{
aRaiz = pRaiz;
aPrimerHijo = null;
aSgteHermano = null;
}
/* ---------------------------------------------------------- */
public static CArbol crearArbol()
{
return new CArbol();
}
/* ---------------------------------------------------------- */
public static CArbol crearArbol( Object pRaiz)
{
return new CArbol(pRaiz);
}
/* ====================
Modificadores
=================== */
/* ---------------------------------------------------------- */
public void modificarRaiz( Object pRaiz)
{
aRaiz = pRaiz;
}
/* ---------------------------------------------------------- */
public void modificarPrimerHijo( CArbol pPrimerHijo)
{
aPrimerHijo = pPrimerHijo;
}
/* ---------------------------------------------------------- */
public void modificarSgteHermano( CArbol pSgteHermano)
{
aSgteHermano = pSgteHermano;
}
/* ====================
Selectores
==================== */
/* ---------------------------------------------------------- */
public Object raiz()
{
return aRaiz;
}
/* ---------------------------------------------------------- */
public CArbol primerHijo()
{
return aPrimerHijo;
}
/* ---------------------------------------------------------- */
public CArbol sgteHermano()
{
return aSgteHermano;
}
/* ==================
Otros Metodos
==================== */
/* ---------------------------------------------------------- */
public boolean estaVacio()
{
return (aRaiz==null);
}
/* ---------------------------------------------------------- */
public CArbol agregar( CArbol subArbolPadre, Object hijo)
{
/* Si árbol está vacío o subArbolPadre es nulo, agregar hijo
como raíz */
if ((subArbolPadre==null) && (estaVacio()))
{
aRaiz = hijo;
return this;
}
else
{
/* ----- Verificar que subArbolPadre pertenece al arbol */
if (subArbolPadre == subArbol(subArbolPadre.raiz()))
return subArbolPadre.agregarHijo(hijo);
else
{
System.out.println("ERROR. SubArbolPadre no pertence al
arbol");
return null;
}
}
}
/* ---------------------------------------------------------- */
public CArbol agregarHijo(Object hijo)
{
/* Si no existe primer hijo, agregarlo como tal */
if (aPrimerHijo==null)
{
aPrimerHijo = new CArbol(hijo);
return aPrimerHijo;
}
else /* Agregar como hermano de primer hijo */
return aPrimerHijo.agregarHermano(hijo);
}
/* ---------------------------------------------------------- */
public CArbol agregarHijo(Object hijo)
{
/* Si no existe primer hijo, agregarlo como tal */
if (aPrimerHijo==null)
{
aPrimerHijo = new CArbol(hijo);
return aPrimerHijo;
}
else /* Agregar como hermano de primer hijo */
return aPrimerHijo.agregarHermano(hijo);
}
/* ---------------------------------------------------------- */
public CArbol agregarHermano(Object hermano)
{
/* Si no existe siguiente hermano, agregarlo como tal */
if (aSgteHermano==null)
{
aSgteHermano = new CArbol(hermano);
return aSgteHermano;
}
else
return aSgteHermano.agregarHermano(hermano);
}
/* ---------------------------------------------------------- */
public CArbol subArbol(Object pRaiz)
{
if (estaVacio())
return null;
else
/* ----- Verifica si la raiz es del subarbol buscado */
if (aRaiz.equals(pRaiz))
return this;
else
{
/* ----- Buscar en el primer hijo (si existe) */
CArbol arbolAux = null;
if (aPrimerHijo != null)
arbolAux = aPrimerHijo.subArbol(pRaiz);
/* ----- Si no existe en primer hijo,
buscar en siguiente hermano (si existe) */
if ((arbolAux==null) && (aSgteHermano!=null))
arbolAux = aSgteHermano.subArbol(pRaiz);
return arbolAux;
}
}
/* ---------------------------------------------------------- */
public CArbol padre(Object hijo)
{
if (estaVacio())
return null;
else
/* ----- Verifica es hijo de la raíz actual */
if (esHijo(hijo))
return this;
else
{
/* ----- Buscar en el primer hijo (si existe) */
CArbol arbolAux = null;
if (aPrimerHijo != null)
arbolAux = aPrimerHijo.padre(hijo);
/* ----- Si no existe en primer hijo,
buscar en siguiente hermano (si existe) */
if ((arbolAux==null) && (aSgteHermano!=null))
arbolAux = aSgteHermano.padre(hijo);
return arbolAux;
}
}
/* ---------------------------------------------------------- */
public boolean esHijo(Object hijo)
{
if ((estaVacio()) || (aPrimerHijo==null))
return false;
else
return (aPrimerHijo.raiz().equals(hijo)) ? true :
aPrimerHijo.esHermano(hijo);
}
/* ---------------------------------------------------------- */
public boolean esHermano(Object hermano)
{
if ((estaVacio()) || (aSgteHermano==null))
return false;
else
return (aSgteHermano.raiz().equals(hermano)) ? true :
aSgteHermano.esHermano(hermano);
}
/* ---------------------------------------------------------- */
public void eliminar(CArbol pArbol)
{
/* ----- Verificar que pArbol es parte del árbol */
if ((pArbol!=null) && (pArbol==subArbol(pArbol.raiz())))
{
/* ----- Recuperar padre */
CArbol arbolPadre = padre(pArbol.raiz());
/* ----- Si no existe padre, pRaiz es la raíz del árbol */
if (arbolPadre==null)
{
/* ----- Eliminar todo el arbol */
aRaiz = null;
aPrimerHijo = null;
aSgteHermano = null;
}
else /* ----- Eliminar un subarbol */
/* ----- Verificar si pArbol a eliminar es primer hijo */
if (pArbol == arbolPadre.primerHijo())
{
CArbol arbolAux = arbolPadre.primerHijo().sgteHermano();
arbolPadre.modificarPrimerHijo(arbolAux);
}
else /* ----- Objeto a eliminar no es primer hijo */
arbolPadre.primerHijo().eliminarHermano(pArbol);
}
}
/* ---------------------------------------------------------- */
protected void eliminarHermano(CArbol pArbol)
{
if (pArbol == aSgteHermano)
modificarSgteHermano(aSgteHermano.sgteHermano());
else
aSgteHermano.eliminarHermano(pArbol);
}
/* ---------------------------------------------------------- */
public void procesar()
{
if (!estaVacio())
System.out.println(raiz());
}
/* ---------------------------------------------------------- */
public void preOrden()
{
if (!estaVacio())
{
procesar();
if (aPrimerHijo != null)
{
aPrimerHijo.preOrden();
aPrimerHijo.recorrerHermanoPreOrden();
}
}
}
/* ---------------------------------------------------------- */
protected void recorrerHermanoPreOrden()
{
if (aSgteHermano != null)
{
aSgteHermano.preOrden();
aSgteHermano.recorrerHermanoPreOrden();
}
}
/* ---------------------------------------------------------- */
public void inOrden()
{
if (!estaVacio())
{
if (primerHijo() != null)
primerHijo().inOrden();
procesar();
if (primerHijo() != null)
primerHijo().recorrerHermanoInOrden();
}
}
/* ---------------------------------------------------------- */
protected void recorrerHermanoInOrden()
{
if (aSgteHermano!=null)
{
aSgteHermano.inOrden();
aSgteHermano.recorrerHermanoInOrden();
}
}
/* ---------------------------------------------------------- */
public void posOrden()
{
if (!estaVacio())
{
if (aPrimerHijo != null)
{
aPrimerHijo.posOrden();
aPrimerHijo.recorrerHermanoPosOrden();
}
procesar();
}
}
/* ---------------------------------------------------------- */
protected void recorrerHermanoPosOrden()
{
if (aSgteHermano != null)
{
aSgteHermano.recorrerHermanoPosOrden();
aSgteHermano.posOrden();
}
}
/* ---------------------------------------------------------- */
public int altura()
{
if (estaVacio())
return 0;
else
if (aPrimerHijo != null)
{
int altura1 = 1+aPrimerHijo.altura();
int altura2 = 1+aPrimerHijo.alturaHermanos();
return (altura1>altura2?altura1:altura2);
}
else // Arbol es una hoja
return 0;
}
/* ---------------------------------------------------------- */
protected int alturaHermanos()
{
if (aSgteHermano==null)
return 0;
else
{
int altura1 = aSgteHermano.altura();
int altura2 = aSgteHermano.alturaHermanos();
return (altura1>altura2?altura1:altura2);
}
}
}