Árboles generales · › búsqueda de un elemento sobre una Árboles general › problemas y...

Javier Vélez Reyes José Ignacio Mayorga [email protected] [email protected]

Departamento de Lenguajes Y Sistemas InformáticosUNED

Estrategias de programación y estructuras de datosGrado en Ingeniería Informática

Grado en Tecnologías de la Información

Departamento de Lenguajes y Sistemas informáticos

Tipos abstractos de datos jerárquicosÁrboles generales

Tipos abstractos de datos jerárquicos. Árboles generales

Javier Vélez Reyes [email protected] José Ignacio Mayorga Toledano [email protected] .es

Índice

Índice

› Introducción

› Tipos abstractos de datos jerárquicos

› El tipo abstracto de datos Árbol general

› Interfaz del tipo abstracto de datos Árbol general

› Implementaciones del tipo abstracto de datos Árbol general

› Implementación dinámica

› Implementación estática con array de posiciones variables

› Algoritmos sobre Árboles generales

› Recorrido de los elementos de un Árbol general

› Búsqueda de un elemento sobre una Árboles general

› Problemas y ejercicios

› Bibliografía



Objetivos generales

Objetivos

› Conocer la interfaz del tipo abstracto de datos Árbol general

› Aprender a implementar el TAD Árbol general mediante la interfaz TreeIF

› En versión estática (con limitación explícita de capacidad máxima)

› En versión dinámica (sin limitación explícita de capacidad máxima)

› Conocer los principales problemas algorítmicos sobre árboles generales

› Recorrido de los elementos de un árboles generales

› Búsqueda de un elemento sobre un árboles generales

› Practicar el diseño de funciones recursivas sobre árboles generales



Introducción

Tipos abstractos de datos jerárquicos

Los tipos abstractos de datos jerárquicos representan abstracciones en las que los datos sedistribuyen a través de relaciones de parento-filialidad donde cada elemento tiene un padrey varios hijos. En función del número máximo de hijos que puede tener un elementodistinguiremos entre árboles binarios (con 2 hijos como máximo) y árboles generales (sinlimitación en el número de hijos). Aunque los segundos pueden considerarse unageneralización de los primeros, ambos presentan implementaciones y escenarios de usodiferentes lo que justifica su consideración como tipos distintos

Tipos abstractos de datos lineales

I. Árboles generales

II. Árboles binariosUn árbol binario es un tipo especial de árbol donde cada elementodel mismo puede referenciar a lo sumo a 2 hijos. Este tipo deestructuras se utilizan frecuentemente para representar encomputación no sólo conjuntos de datos con una relación dedependencia padre-hijo sino también para articular esquemas debúsqueda eficientes

Los árboles generales pueden considerarse a todos los efectos unageneralización de los árboles binarios donde el número de hijosestá limitado por una constante k > 2 (o no existe limitación en elnúmero de hijos). Aunque, en principio, es posible expresar todoárbol general como un árbol binario, existen situaciones encomputación donde este tipo de abstracciones tiene usosinteresantes

Tema 7

Tema 8



Introducción

El tipo abstracto de datos Árbol general

Un árbol general es una estructura que organiza una colección de elementos a través de una relaciónde parento-filialidad donde cada elemento dispone a lo sumo de un padre y de un número de hijosno prefijado . Si un elemento no tiene padre se llama nodo raíz. En un árbol general hay siempre un ysólo un elemento raíz. Si un elemento no tiene hijos se llama elemento hoja. La definicióncomputable del tipo se establece recursivamente de la siguiente manera

Un árbol general es un tipo abstracto de datos que da acceso directo a un

elemento llamado raíz y, a un número indeterminado de subárboles que dependen

jerárquicamente de él como hijos llamados

SubárbolesLos árboles generales pueden tener cualquier número de hijos

0

1 7

2

4

8 9

3

5 6 Elemento hojaCuando un elemento no tiene hijos se llama hoja

RaízLa raíz es el elemento del que cuelga el resto de nodos

NivelesEl número de niveles de un árbol indica la

separación máxima que hay entre la raíz y la

hoja más alejada de ésta

medida en número de

arcos



Interfaz del tipo abstracto de datos Árbol general

La interfaz del tipo abstracto de datos Árbol general TreeIF <T>

public interface TreeIF <T>{

public int PREORDER = 0;public int POSTORDER = 1;public int LRBREADTH = 2;public int RLBREADTH = 3;

/*** Devuelve el elemento raiz del arbol.* @return el elemento raiz del arbol.*/

public T getRoot ();

/*** Establece el elemento raiz.* @param element El elemento a establecer.*/

public void setRoot (T element);

/*** Devuelve el primer los hijos de un arbol.* @return los hijos de un arbol.*/

public ListIF <TreeIF <T>> getChildren ();

/*** Inserta un subarbol como ultimo hijo.* @param child el hijo a insertar. */

public void addChild (TreeIF<T> child);

El interfaz de Árbol general que utilizaremos a lo largode este curso, TreeIF está compuesto por lasoperaciones que describimos a continuación

RecorridosEstas constantes sirven para identificar en elmétodo getIterator distintas estrategias derecorrido de los elementos del árbol

Obtener raízDevuelve la raíz del árbol. Este métododevuelve un elemento de tipo T distinto de nulo

Establecer raízEsta operación establece el valor asignado a laraíz de un del árbol. Si el valor es null laoperación no tiene efecto

Obtener hijos Esta operación consultora devuelve la lista detodos los subárboles que son hijos del nodo encurso

1

2 4

1

3

0

2 4

0

3

1

2 43

2 43

Añadir nuevo hijoA través de esta operación se puede añadir unnuevo subárbol como hijo más a la derecha enla colección de hijos

1

2 43

4



Interfaz del tipo abstracto de datos Árbol general

La interfaz del tipo abstracto de datos Árbol general TreeIF <T>

/*** Extrae un subarbol como hijo.* @param index el indice del subarbol con base en 0. */

public void removeChild (int index);

/*** Devuelce cierto si el arbol es un nodo hoja.* @return cierto si el arbol es un nodo hoja.*/

public boolean isLeaf ();

/*** Devuelve cierto si el arbol es vacio.* @return cierto si el arbol es vacio.*/

public boolean isEmpty ();

/*** Devuelve cierto si la lista contiene el elemento.* @param element El elemento buscado.* @return cierto si la lista contiene el elemento.*/

public boolean contains (T element);

/*** Devuelve un iterador para la lista.* @param traversalType El tipo de recorrido.* @return un iterador para la lista.*/

public IteratorIF<T> getIterator (int traversalType);}

El interfaz de Árbol general que utilizaremos a lo largode este curso, BTreeIF está compuesto por lasoperaciones que describimos a continuación

Eliminar hijoA través de esta operación se borra el hijo enla posición indicada por index en la colección

Es hojaEsta operación consultora indica si el nodo encurso es un nodo hoja o no lo es

Es vacioEsta operación consultora indica si el árbol encurso es vacío o no

BúsquedaEsta operación busca un elemento dentro dela estructura jerárquica del árbol

RecorridoEsta operación devuelve un iterador quepermite acceder a todos los elementos delárbol

1

2 43

2

1

2 4

false

3true

1

2 43

false

false

true

1

2 4

true

3

3

1

2 4

1,2,3,4

3



Implementación del tipo abstracto de datos Árbol general

Implementación del tipo abstracto de datos Árbol general TreeIF <T>

Existen varias estrategias de implementación árboles generales que responden al interfazTreeIF anterior. Éstas se dividen en implementaciones dinámicas, con capacidad indefinidapara almacenar elementos e implementaciones estáticas, con una capacidad máximalimitada establecida por parámetro. A continuación presentamos varias implementaciones

Implementación dinámica basada en cola de hijosSegún esta estrategia de implementación, un árbol es un objeto que representa el nodoraíz del mismo. Cada nodo tiene un atributo para almacenar el valor del elemento y unacola de árboles que contienen referencias a los hijos

ElementoAlmacena el valor

del dato en el nodo

1

2 5e

HijosLista de referencias a subárboles hijo

-

3 - 3 -

8

7 - 9 -




public class TreeDynamic <T> implements TreeIF <T> *{

private T element;private QueueIF<TreeIF <T>> children;

public TreeDynamic (){

this.element = null;this.children = new QueueDynamic <TreeIF <T>> ();

}

public TreeDynamic (T element){

this.element = element;this.children = new QueueDynamic <TreeIF <T>> ();

}

public TreeDynamic (TreeIF<T> tree){

this.element = tree.getRoot ();this.children = new QueueDynamic <TreeIF <T>> ();

ListIF <TreeIF <T>> tChildren = tree.getChildren ();while (!tChildren.isEmpty ()) {

TreeIF <T> aChild = tChildren.getFirst ();TreeIF <T> cChild = new TreeDynamic <T> (aChild);children.add (cChild);tChildren = tChildren.getTail ();

}}

Implementación dinámica basada en cola de hijos

@Overridepublic T getRoot () {

return element;}

@Overridepublic ListIF <TreeIF <T>> getChildren (){

ListIF <TreeIF <T>> lChildren = new ListDynamic <TreeIF <T>> ();;StackIF <TreeIF <T>> sChildren = new StackDynamic <TreeIF <T>> ();IteratorIF<TreeIF<T>> childrenIt = children.getIterator ();while (childrenIt.hasNext ()) {

TreeIF<T> aChild = childrenIt.getNext ();sChildren.push (aChild);

}while (!sChildren.isEmpty ()) {

TreeIF<T> aChild = sChildren.getTop ();lChildren.insert (aChild);sChildren.pop ();

} return lChildren;

}

@Overridepublic void setRoot (T element){

this.element = element;}

Según esta estrategia de implementación, un árbol es un objeto que representa el nodoraíz del mismo. Cada nodo tiene un atributo para almacenar el valor del elemento y unacola de árboles que contienen referencias a los hijos

* Los comentarios de las cabeceras sehan omitido por cuestiones de espacio




@Overridepublic void addChild (TreeIF<T> child){

children.add (child);}

@Overridepublic void removeChild (int index) {

QueueIF <TreeIF<T>> aux = new QueueDynamic <TreeIF<T>> ();for (int i = 0; i < children.getLength (); i++) {

TreeIF <T> aChild = children.getFirst ();if (i != index) aux.add (aChild);children.remove ();

}children = aux;

}

@Overridepublic boolean isLeaf (){

return children.isEmpty ();}

@Overridepublic boolean isEmpty () {

return element == null &&children.isEmpty ();

}

Implementación dinámica basada en cola de hijos

@Overridepublic boolean contains (T element){

if (this.element.equals (element)) return true;else {

IteratorIF <TreeIF <T>> childrenIt = children.getIterator ();boolean found = false;while (!found && childrenIt.hasNext ()) {

TreeIF <T> aChild = childrenIt.getNext ();found = aChild.contains (element);

}return found;

}}

@Overridepublic IteratorIF<T> getIterator (int type) {

TreeIF<T> handler = new TreeDynamic<T> (this);return new TreeIterator<T> (handler, type);

}

@Overridepublic int hashCode () {...}

@Overridepublic boolean equals () {...}

@Overridepublic String toString () {...}

}

Según esta estrategia de implementación, un árbol es un objeto que representa el nodoraíz del mismo. Cada nodo tiene un atributo para almacenar el valor del elemento y unacola de árboles que contienen referencias a los hijos

* Los comentarios de las cabeceras sehan omitido por cuestiones de espacio




Implementación del tipo abstracto de datos Árbol general TreeIF <T>

Implementación estática mediante array de posiciones hijas variablesEn esta implementación un árbol se representa como un array de nodos. El valor delnodo raíz se encuentra en la posición 0. Cada nodo tiene el valor del elemento que portay la lista de índices que indican las posiciones dentro del array donde están los nodoshijos

Capacidad máxima y longitud La capacidad se expresa ennúmero de nodos0

1 7

2

4

8 9

3

5 6

8 96 74 52 30 1

Existen varias estrategias de implementación árboles generales que responden al interfazTreeIF anterior. Éstas se dividen en implementaciones dinámicas, con capacidad indefinidapara almacenar elementos e implementaciones estáticas, con una capacidad máximalimitada establecida por parámetro. A continuación presentamos varias implementaciones

0

356

1

9

4

47

7

21

8 9 25 6 3

8



Algoritmos sobre árboles generales


Como viene siendo frecuente a lo largo de este curso, los tres tipos de algoritmos canónicosaplicables a cualquier estructura de datos son recorrido, búsqueda y ordenación. En estecaso, la ordenación debe entenderse como una reorganización de los nodos del árbol parafavorecer algún criterio (típicamente la búsqueda). Sin embargo, no estudiaremos ningúnalgoritmo de ordenación y nos centraremos sólo en recorridos y búsquedas

Algoritmos sobre árboles

generales

I. RecorridoEl recorrido de los elementos de un árbol general devuelve un iterador quepermite acceder secuencialmente a los mismos según aparecenalmacenados en la estructura. Sin embargo, existen distintos criterios desecuenciamiento que pueden aplicarse para construir un recorrido. Aquíestudiaremos los más típicamente aplicados

II. BúsquedaLa búsqueda de un elemento sobre los nodos de un árbol general se realizade forma recursiva dada la definición del tipo lo que imprime un coste linealal algoritmo en el peor caso. La ventaja de este tipo de algoritmos, conrespecto a sus equivalentes en otras estructuras de datos es que el procesono es destructivo con lo que no se requiere utilizar un iterador (con copia) nireconstruir la estructura tras la aplicación del algoritmo

Independencia de la im

plementación




Recorrido de los elementos de un árbol general

Los recorridos que pueden aplicarse sobre las estructuras arborescentes son varios enfunción de la estrategia de secuenciamiento que se aplique sobre los elementos del tipoabstracto de datos. En concreto es posible distinguir 4 estrategias organizados de lasiguiente manera

Rec

orrid

os

sobr

e ár

bole

s

I. Recorridos en profundidadSe recorre el árbol recursivamenteen profundidad. En función dedonde se aloje, relativamente cadanodo con respecto a sus hijos sedistinguen 2 recorridos

II. Recorridos en anchura

Preorden

Postorden

Cada nodo se inserta antes dela colección de nodoscorrespondiente a susdescendentes

Cada nodo se inserta detrás dela colección de nodoscorrespondiente a susdescendentes

S A C O

S A O S

Se recorre el árbol en anchuracolocando primero todos loselementos del nivel k antes depasar a colocar los del nivel k + 1.En función del orden en que sedisponen los elementos por nivelesse distinguen dos recorridos enanchura

Anchura

Anchura inversa

Se disponen los elementos delárbol por niveles de izquierda aderecha y desde la raíz a lashojas

Se disponen los elementos deforma inversa a como estableceun recorrido en anchura

O C A S

S A C O




Recorrido de los elementos de una árbol general

Para implementar el iterador de los árboles generales utilizaremos una cola donde sealmacenarán en la construcción los elementos dispuestos adecuadamente según el tipo derecorrido seleccionado. La iteración entonces se delegará en el iterador de esa cola

public class TreeIterator<T> implements IteratorIF<T> {

private IteratorIF<T> iterator;

/*** Constructor para TreeIterator.* @param handler el manejador de arboles.* @param type el tipo de recorrido.*/public TreeIterator (TreeIF<T> handler, int type){

QueueIF<T> traverse = null;switch (type) {

case TreeIF.PREORDER: traverse = preorder (handler); break;case TreeIF.POSTORDER: traverse = postorder (handler); break;case TreeIF.LRBREADTH: traverse = lrBreadth (handler); break; case TreeIF.RLBREADTH: traverse = rlBreadth (handler); break;

}this.iterator = new QueueIterator<T> (traverse);

}

/*** Devuelve el siguiente elemento de la iteracion. * @return el siguiente elemento de la iteracion.*/@Overridepublic T getNext () {

return iterator.getNext ();}

La iteración de los elementos del árbol se delegaen el iterador de cola que es construido en elconstructor. La función de reset está garantizada

Iteración con reset

La función de avance delega en el iterador decola que se ha construido previamente. Estaaproximación simplifica las operaciones peropenaliza el tiempo de la construcción del iterador

Avance

ConstrucciónEn función del valor del parámetro del tipo derecorrido, el constructor invoca a una u otrafunción privada que devuelve una cola con loselementos dispuestos en el orden apropiado.Después se construye un iterador sobre la colaresultante




/*** Devuelve cierto si existen mas elementos en el iterador.* @return cierto si existen mas elementos en el iterador.*/@Overridepublic boolean hasNext () {

return iterator.hasNext ();}

/*** Restablece el iterador para volver a recorrer la estructura.*/@Override public void reset () {

iterator.reset ();}

private QueueIF<T> preorder (TreeIF<T> tree){

QueueIF<T> traverse = new QueueDynamic<T> (); T element = tree.getRoot ();traverse.add (element); IteratorIF <TreeIF <T>> childrenIt = tree.getChildren ().getIterator ();while (childrenIt.hasNext ()) {

TreeIF <T> aChild = childrenIt.getNext ();QueueIF <T> aTraverse = preorder (aChild);addAll (traverse, aTraverse);

} return traverse;

}

La función de siguiente se delega sobre eliterador de cola. Habrá siguientes elementos quevisitar si el iterador de cola aún no ha finalizado

Siguiente

El recorrido en preorden inserta primero en lacola cada nodo y luego construye recursivamentelas colas de los subárboles hijos. Mediante elmétodo allAll dichas colas se añaden, en eseorden a la cola principal.

Preorden

ResetLa función de restablecimiento del iterador sedelega igualmente sobre el método homónimodel iterador de colas






private QueueIF<T> postorder (TreeIF<T> tree){

QueueIF<T> traverse = new QueueDynamic<T> (); T element = tree.getRoot ();IteratorIF <TreeIF <T>> childrenIt = tree.getChildren ().getIterator ();while (childrenIt.hasNext ()) {

TreeIF <T> aChild = childrenIt.getNext ();QueueIF <T> aTraverse = preorder (aChild);addAll (traverse, aTraverse);

} traverse.add (element); return traverse;

}

private QueueIF<T> lrBreadth (TreeIF<T> tree) {QueueIF<T> traverse = new QueueDynamic <T> (); QueueIF<TreeIF<T>> aux = new QueueDynamic <TreeIF<T>> ();

aux.add (tree);while (!aux.isEmpty ()) {

TreeIF<T> aTree = aux.getFirst ();T element = tree.getRoot ();IteratorIF <TreeIF <T>> childrenIt = aTree.getChildren ().getIterator ();while (childrenIt.hasNext ()) {

TreeIF <T> aChild = childrenIt.getNext ();aux.add (aChild);

} traverse.add (element);aux.remove ();

} return traverse;

}

El recorrido en postorden insertaprimero los elementos de los subárboleshijos y después anexa el nodo en curso.

Postorden

El recorrido en anchura utiliza dos colaspara su construcción. En una se vaninsertando los elementos resultantes delrecorrido. La otra es una cola auxiliarque sirve para almacenar lossubárboles pendientes de serprocesados en cada paso

Anchura






private QueueIF<T> rlBreadth (TreeIF<T> tree){

QueueIF<T> traverse = lrBreadth (tree); StackIF<T> aux = new StackDynamic<T> ();while (!traverse.isEmpty ()) {

T element = traverse.getFirst ();aux.push (element);traverse.remove ();

}while (!aux.isEmpty ()) {

T element = aux.getTop ();traverse.add (element);aux.pop ();

}return traverse;

}

private void addAll (QueueIF<T> q, QueueIF<T> p){

while (!p.isEmpty ()) {T element = p.getFirst ();q.add (element);p.remove ();

}}

}

La anchura inversa es el recorrido inverso alanterior por tanto la implementación más sencillaconsiste en generar un recorrido en anchura einvertirlo posteriormente. Para ello se utiliza unapila. Primero se mueven los elementos de la colaresultante a una pila. Después se extraen de lacola para insertarlos en una pilla. Finalmente seextraen de la pila para insertarlos nuevamente enla cola

Anchura inversa

La función addAll inserta en una cola todos loselementos de una segunda cola

Encolar todos






Búsqueda de un elemento sobre un árbol general

La búsqueda de un dato sobre los elementos contenidos en un árbol general es unproblema de recorrido que termina cuando se encuentra el elemento buscado dentro de laestructura de datos. Dado que se trata de un tipo con definición recursiva el algoritmo seráesencialmente iterar sobre cada hijo para aplicar sobre él recursivamente el algoritmo

Búsqueda recursiva iterada

public boolean contains (T element){

if (this.element.equals (element)) return true;else {

IteratorIF <TreeIF <T>> childrenIt = children.getIterator ();boolean found = false;while (!found && childrenIt.hasNext ()) {

TreeIF <T> aChild = childrenIt.getNext ();found = aChild.contains (element);

}return found;

}}

Como puede apreciarse este algoritmo es agnóstico de la estructura de implementaciónsubyacente ya que se apoya en operaciones definidas en el interfaz de árbol general TreeIF.En primer lugar, se comprueba si el nodo raiz coincide con el elemento buscado. Si es así,hemos terminado. Sino, debemos iterar sobre cada uno de los hijos realizando unabúsqueda con centinela en la colección de hijos pero recursiva en cada hijo



Problemas y ejercicios

Ejercicios

Pueden encontrarse multitud de situaciones donde es necesario manipular la estructurainterna de los elementos de un árbol general. A continuación presentamos algunosejercicios que vienen a ejemplificar tales situaciones

Diseñe una función devuelva elnúmero de elementos que contieneun árbol general

I. Contar elementosDiseñe una función que devuelve lasuma de todos los elementos de unárbol general de enteros

II. Sumar elementosDiseñe una función recursiva quedevuelva una lista con todos loselementos pares de un árbol deenteros

III. Encontrar pares

Diseñe una función recursiva quedado un árbol de enteros devuelvaotro árbol solamente con loselementos pares

IV. Eliminar imparesDiseñe una función dado un árbol deenteros multiplique el valor en cadanodo por su altura

V. AlturasDiseñe una función recursiva quedetermine si dos árboles generalesson estructuralmente idénticos

VI. Comparación de árboles

Diseñe una función recursiva queindique si dos árboles son la imagenespecular el uno del otro

VII. Imagen especularDiseñe una función que dado unárbol general de enteros sustituya elvalor en cada nodo por el valoracumulado de todos los nodosanteriores a el en un recorrido enprofundidad

VIII. Sumar anteriores




Problemas

Los árboles generales son un tipo abstracto de datos que se utiliza recurrentemente en losproblemas de cierta complejidad de programación. A continuación planteamos algunosejemplos de problemas que se resuelven con el uso de este tipo abstracto de datos.

Una cola de prioridad es un tipo especial de coladonde las inserciones se realizan por orden deacuerdo a un criterio comparativo entre loselementos de la cola. La implementación máseficiente se realiza con árboles generales donde enel nivel k están los elementos de prioridad k

Colas de prioridad

Árboles de decisión

En inteligencia artificial y minería de datos seutilizan árboles de decisión para representarproblemas de decisión. Cada nodo representa uncriterio de decisión y las ramas de éste las posiblesalternativas

0

1 1

2

1

2 22 2




Problemas

Los datos almacenados en una base de datossuelen mantenerse gestionados medianteestructuras arbóreas complejas de un nivel fijo deprofundidad (nivel raiz, nivel de página, nivel dehoja y nivel de registro, etc.)

Bases de datos

Juegos

La inteligencia artificial de muchos juegos deestrategia, como el ajedrez o las tres en ralla, utilizaárboles para representar el espacio de búsquedade las alternativas de movimiento dentro del juegovalorando con una función de utilidad el beneficio,positivo o negativo, de realizarlo. Una funciónumbral permite tomar la decisión

Las árboles generales son un tipo abstracto de datos que se utiliza recurrentemente en losproblemas de cierta complejidad de programación. A continuación planteamos algunosejemplos de problemas que se resuelven con el uso de este tipo abstracto de datos.



Bibliografía

Bibliografía

Bibliografía básica

Estructuras de datos en java. Weiss, Mark

Allen. Pearson Addison – Wesley. ISBN

9788478290352



Bibliografía

Bibliografía

Bibliografía complementaria

Estructura de datos y algoritmos en java. A.

Drozdek. Thomsom. ISBN: 9706866116. 2007

Estructuras de datos con Java. J. Lewis, J.

Chase. Pearson – Addison Wesley. ISBN 13:

9788420541914

Árboles generales · › búsqueda de un elemento sobre una Árboles general › problemas y...

Documents