Algoritmos y Estructuras de Datos Avanzadas:

Árboles Generales

Clemente Rubio Manzano

Magister en Ciencias de la Computación — Universidad del Bío-Bío (Chile)

Noviembre’11

Clemente Rubio Manzano (Magister en Ciencias

Algoritmos
de la Computación
y Estructuras
—de
Universidad
Datos Avanzadas:
del Bío-Bío
Árboles
(Chile))
Generales
Noviembre’11 1 / 11
 Índice

Clemente Rubio Manzano (Magister en Ciencias

Algoritmos
de la Computación
y Estructuras
—de
Universidad
Datos Avanzadas:
del Bío-Bío
Árboles
(Chile))
Generales
Noviembre’11 2 / 11
 Definición

Un árbol general es un conjunto no vacío de elementos

compuesto por:
un elemento distinguido llamado raíz.
una colección finita de árboles generales que son subárboles del
original.
Ahora no existe el árbol vacío; lo que puede ser vacía es la
colección de subárboles.
Lugar que ocupan los hijos en la colección es irrelevante y el
número de hijos de cada nodo no tiene por qué coincidir.

Clemente Rubio Manzano (Magister en Ciencias

Algoritmos
de la Computación
y Estructuras
—de
Universidad
Datos Avanzadas:
del Bío-Bío
Árboles
(Chile))
Generales
Noviembre’11 3 / 11
 Especificación Algebraica

TIPO: ARBOLGENERAL
Tipos: ELEMENTO, LÓGICO, LISTAARBGEN
Operaciones básicas:
ARBOLGENVACIO: → ARBOLGEN
CREAARBOLGEN: ELEMENTO × LISTA<ARBOLGEN> →
ARBOLGEN
RAIZGEN: ARBOLGEN → ELEMENTO
HIJOSGEN: ARBOLGEN → LISTA<ARBOLGEN>
ESVACIO: ARBOLGEN → LÓGICO
Más todas las operaciones del TAD lista: ListaVacía, Añadeppio,
AñadeFinal, Primero, Resto, EsListaVacía, Último, Borrar,
Posicion,Pertenece,. . ..

Clemente Rubio Manzano (Magister en Ciencias

Algoritmos
de la Computación
y Estructuras
—de
Universidad
Datos Avanzadas:
del Bío-Bío
Árboles
(Chile))
Generales
Noviembre’11 4 / 11
 Implementación: Constructor, métodos

import java.util.ArrayList;

class ArbolGeneral<Elemento> implements Cloneable{

//un arbol general es un elemento raiz y una lista de arboles generales
private Elemento raiz;
private ArrayList<ArbolGeneral<Elemento>> hijos;

public ArbolGeneral(){
this(null);//raiz=null
}

public ArbolGeneral(Elemento ob){

raiz=ob;
hijos=new ArrayList<ArbolGeneral<Elemento>>();
}

public ArbolGeneral(Elemento ob, ArrayList<ArbolGeneral<Elemento>> h){

this(ob);
if(raiz!=null && h!=null) hijos=h;
}

public boolean esVacio(){ return raiz==null; }

public Elemento raiz(){ return raiz; }

//ojo las referencias son las mismas

protected ArrayList<ArbolGeneral<Elemento>> hijos(){
return hijos;
}

Clemente Rubio Manzano (Magister en Ciencias

Algoritmos
de la Computación
y Estructuras
—de
Universidad
Datos Avanzadas:
del Bío-Bío
Árboles
(Chile))
Generales
Noviembre’11 5 / 11
 Implementación: Hijos

public ArrayList<Elemento> hijosOb(){

//son las raices nada mas
ArrayList<Elemento> hijos=new ArrayList<Elemento>();

if(!esVacio()){
ArrayList<ArbolGeneral<Elemento>> aux=hijos();
for (int i=0; i < aux.size(); i++){
hijos.add(aux.get(i).raiz());
}
}
return hijos;

}//fin del mà todo

c hijosOb

public void nuevoHijo(Elemento e){

if(esVacio()){
raiz=e;
hijos=new ArrayList<ArbolGeneral<Elemento>>();
}else nuevoHijo(new ArbolGeneral<Elemento>(e));
}

public void nuevoHijo(ArbolGeneral<Elemento> a){

if(a!=this && !a.esVacio()) hijos.add(a);
}

Clemente Rubio Manzano (Magister en Ciencias

Algoritmos
de la Computación
y Estructuras
—de
Universidad
Datos Avanzadas:
del Bío-Bío
Árboles
(Chile))
Generales
Noviembre’11 6 / 11
 Implementación: localiza

public ArbolGeneral<Elemento> localiza(Elemento ob){

ArbolGeneral<Elemento> loca=new ArbolGeneral<Elemento>();
if (!esVacio()){
if (raiz().equals(ob)) loca=this;
else {
ArrayList<ArbolGeneral<Elemento>> hijos=hijos();
for(int i=0; i < hijos.size() && loca.esVacio(); i++){
loca=hijos.get(i).localiza(ob);
}
}
}
return loca;
}//localiza

public boolean pertenece(Elemento ob){ return !localiza(ob).esVacio(); }

public void eliminar(Elemento dato){

//elimina todas las apariciones de dato y sus ramas
if(!esVacio()){
if (raiz().equals(dato)){
raiz=null;
hijos=new ArrayList<ArbolGeneral<Elemento>>();
}else{
ArrayList<ArbolGeneral<Elemento>> hijos=hijos();
while(hijosOb().indexOf(dato)>0) hijos.remove(hijosOb().indexOf(dato));
for(int i=0; i < hijos.size(); i++) { hijos.get(i).eliminar(dato); }
}
}
}

Clemente Rubio Manzano (Magister en Ciencias

Algoritmos
de la Computación
y Estructuras
—de
Universidad
Datos Avanzadas:
del Bío-Bío
Árboles
(Chile))
Generales
Noviembre’11 7 / 11
 Implementación: padre, toString

public ArbolGeneral<Elemento> padre(Elemento ob){

ArbolGeneral<Elemento> aux=new ArbolGeneral<Elemento>();
if (!esVacio()){
if (hijosOb().contains(ob)) aux=this;
else{
ArrayList<ArbolGeneral<Elemento>> hijos=hijos();
for (int n=1;n<=hijos.size() && aux.esVacio();n++)
aux=hijos.get(n).padre(ob);
}
}
return aux;
}
@Override public String toString(){ return "\n"+toString(0); }

public String toString(int espacios){

String linea="\n";
for (int e=0;e<=espacios;e++) linea=linea+" ";
if(esVacio()) linea=linea+"vacio";
else{
linea=linea+raiz().toString()+" "+getClass();
ArrayList<ArbolGeneral<Elemento>> hijos=hijos();
for (int n=0;n< hijos.size();n++)
linea=linea+hijos.get(n).toString(espacios+2);
}
return linea;
}

Clemente Rubio Manzano (Magister en Ciencias

Algoritmos
de la Computación
y Estructuras
—de
Universidad
Datos Avanzadas:
del Bío-Bío
Árboles
(Chile))
Generales
Noviembre’11 8 / 11
 Implementación: Altura y Profundidad

public int altura()throws Exception{

int i=0;
if (!esVacio()){
ArrayList<ArbolGeneral<Elemento>> hijos=hijos();
for (int n=1;n<=hijos.size();n++)
i=Math.max(i,1+hijos.get(n).altura());
}
return i;
}

public int profundidad(Elemento a){

//devuelve la profundidad de a con respecto a this. Es el nivel
int prof=-1;
if (!esVacio()){
if (raiz().equals(a)) prof=0;
else {
ArrayList<ArbolGeneral<Elemento>> hijos=hijos();
for(int i=0; prof<0 && i < hijos.size(); i++){
prof=hijos.get(i).profundidad(a);
if (prof!=-1) prof++;
}
}
}
return prof;
}

Clemente Rubio Manzano (Magister en Ciencias

Algoritmos
de la Computación
y Estructuras
—de
Universidad
Datos Avanzadas:
del Bío-Bío
Árboles
(Chile))
Generales
Noviembre’11 9 / 11
 Implementación: esHoja, equals

public int profundidad(ArbolGeneral<Elemento> a){

int prof=-1;
if (!esVacio()){
if (this.equals(a)) prof=0;
else {
ArrayList<ArbolGeneral<Elemento>> hijos=hijos();
for(int i=0; prof<0 && i < hijos.size(); i++){
prof=hijos.get(i).profundidad(a);
if (prof!=-1) prof++;
}
}
}
return prof;
}

public boolean esHoja(){ return !esVacio() && hijos().isEmpty(); }

@Override public boolean equals(Object a){

boolean iguales=false;
if (!iguales && a instanceof ArbolGeneral){
ArbolGeneral<Elemento> ag=(ArbolGeneral<Elemento>)a;
if((esVacio() && ag.esVacio())||this==ag) iguales=true;
else//no hace falta controlar que uno es vacio y el otro no
if(!esVacio() && !ag.esVacio()) iguales=raiz().equals(ag.raiz()) && hijos().equals(a
}
return iguales;
}

Clemente Rubio Manzano (Magister en Ciencias

Algoritmos
de la Computación
y Estructuras
—de
Universidad
Datos Avanzadas:
del Bío-Bío
Árboles
(Chile))
Generales
Noviembre’11 10 / 11
 Implementación: Recorrido en Anchura, clone

public ArrayList<Elemento> recAnchura(){

ArrayList<ArbolGeneral<Elemento>> ar=new ArrayList<ArbolGeneral<Elemento>>();
ArrayList<Elemento> rec=new ArrayList<Elemento>();
if(!esVacio()){
ar.add(this);
for(int i=0; i < ar.size() ; i++){
ArbolGeneral<Elemento> p=ar.get(i);
rec.add(p.raiz());
ArrayList<ArbolGeneral<Elemento>> hijos=p.hijos();
for(int j=0 ; j < hijos.size(); j++){
ar.add(hijos.get(j));
}
}
}
return rec;
}

@Override public ArbolGeneral<Elemento> clone()throws CloneNotSupportedException{

ArbolGeneral<Elemento> copia=new ArbolGeneral<Elemento>();
if(!esVacio()){
copia=new ArbolGeneral<Elemento>(raiz());
ArrayList<ArbolGeneral<Elemento>> hijos=hijos();
for(int i=0 ; i < hijos.size(); i++){//mas profunda que copia.hijos=hijos.clone()
copia.hijos().add(hijos.get(i).clone());
}
}
return copia;
}//clone
}//arbolGeneral

Clemente Rubio Manzano (Magister en Ciencias

Algoritmos
de la Computación
y Estructuras
—de
Universidad
Datos Avanzadas:
del Bío-Bío
Árboles
(Chile))
Generales
Noviembre’11 11 / 11