30/05/13 Búsqueda en amplitud y profundidad en árboles | vidasConcurrentes

blog.vidasconcurrentes.com/programacion/busqueda-en-profundidad-y-busqueda-en-anchura/ 1/12

Home Blog Síguenos Conócenos Contacto Escribe aquí para buscar...

← Rogue AP con karmetasploit Obteniendo información de dispositivos Androidcon Metasploit →

En programación es muy común usar Estructuras de Datos para poder ordenar y almacenarinformación. Ésta puede ser desde primitivas como números enteros hasta cadenas de textohasta tipos definidos por el programador como productos, personas o estados de un juego.

Existen diversas Estructuras de Datos entre las cuales están los arrays, las listas, las colas, laspilas, los conjuntos, los árboles, los grafos… En esta entrada vamos a centrarnos en los árboles yen los dos algoritmos de búsqueda más sencillos que podemos usar en ellos: la búsqueda enanchura y la búsqueda en profundidad.

Comencemos entonces.

Un árbol es una estructura de datos compuesta por nodos y ramas. Un nodo es un elemento, eldato que queremos organizar. Una rama es una unión dirigida entre un par de nodos. Un nodo sedice que es padre si existe alguna rama que le una con otro nodo, del mismo modo que un nodoes hijo si existe una rama que una a otro nodo con éste. Decimos que un nodo es hoja si no tienehijos. Un grafo es una generalización de un árbol. Para entenderlo mejor, consultemos la siguientefigura:

Búsqueda en anchura y búsqueda en profundidadBúsqueda en anchura y búsqueda en profundidadpara árbolespara árboles

Publicado el Publicado el 16 septiembre, 2011 por por meta

CategoríasCategorías

Android

Curso introducciónAndroid

Programación

Seguridad

Sistemas Operativos

Entradas recientesEntradas recientes

Colorshapes, el juego develocidad mental y figurasde colores para Android

eyeOS: Trabajando en lanube

Integrando GoogleAnalytics en aplicacionesAndroid

Integrando Twitter enaplicaciones Android conSignPost y Twitter4J

Entrenando con

Funcion De VisualBasic

www.3ct.mxAprende Visual Basic Cursocompleto curso presencial en

México DF,

30/05/13 Búsqueda en amplitud y profundidad en árboles | vidasConcurrentes

blog.vidasconcurrentes.com/programacion/busqueda-en-profundidad-y-busqueda-en-anchura/ 2/12

Como toda estructura de datos, los árboles tienen tres operaciones básicas:

Inserción de nuevos elementos.Eliminación de elementos existentes.Búsqueda de un elemento en la estructura.

Existen otras operaciones como la ordenación y la mezcla de dos estructuras de datos del mismotipo, pero no vamos a tratarlas aquí.

Durante el resto de la entrada vamos a utilizar el siguiente árbol:

Comenzamos por tanto, construyendo los tipos de datos necesarios para representar este árbol.En esta ocasion voy a elegir Java como lenguaje de programación por disponer de tipos de datospredefinidos que nos van a ayudar, ya que por ejemplo en C tendríamos que crearnos diversostipos de datos (los cuales veremos más adelante) que pertenecería a una entrada sobreestructuras de datos y su construcción, y no de algoritmos de búsqueda.

Metasploitable (IV). Desdepostgres a ssh, pasandopor openSSL

EtiquetasEtiquetas

acelerometro activityalgoritmo androidaplicacion androidarbol backtrack bash BD

BEeF canvas contraseñas csrf

dns dns spoof eclipseexpresiones regulares

graficos androidgraphics android htc

desire intent javajavascript layout menu

metasploitmetasploitable mitm mysql

oauth owasp pentestingphp seguridad por defecto

shodan smartphones SQL

SQLi trasteando twittertwitter4j VirtualBox wiresharkxml xss persistente

Sitios de interésSitios de interés

Android Developers

Android.es

Backtrack

Command Line Kung Fu

DragonJAR

El Androide Libre

Exploits Database

Flu Project

Gran Angular

Hispasec

Microsiervos

OpenLibra

Pentester.es

Poesía Binaria

Security By Default

Un informático en el ladodel mal

World Wide WebConsistorium

30/05/13 Búsqueda en amplitud y profundidad en árboles | vidasConcurrentes

blog.vidasconcurrentes.com/programacion/busqueda-en-profundidad-y-busqueda-en-anchura/ 3/12

Lo primero será crear nuestra clase NodoArbol, la cual va a representar un nodo de nuestro árbol(duh). En nuestro caso vamos a usar como elemento de cada nodo un carácter, para hacerlosimple. Sin embargo podríamos también usar otras primitivas o nuestros propias clases. Yademás vamos a aceptar que cada nodo pueda tener entre 0 y N hijos, de modo que querremosalgún tipo de lista dinámica para almacenarlo (ya que no sabemos inicialmente cuántos hijoshabrá por nodo). El código de la clase comienza siendo el siguiente:

Además de los atributos que hemos mencionado, añadimos funcionalidad para obtener elelemento del nodo actual y los hijos de dicho nodo, además de la opción de insertar hijos alnodo y de consultar si es un nodo hoja.

Ahora crearemos nuestra clase principal, desde la que vamos a ejecutar las pruebas:

1 public class NodoArbol 2 3 private char elemento;4 private List<NodoArbol> hijos;5 6 public NodoArbol(char elemento) 7 this.elemento = elemento;8 hijos = new ArrayList<NodoArbol>();9 10 11 public char getElemento() 12 return elemento;13 14 15 public void addHijo(NodoArbol hijo) 16 hijos.add(hijo);17 18 19 public List<NodoArbol> getHijos() 20 return hijos;21 22 23 public boolean esNodoHoja() 24 return hijos.size() > 0;25 26

1 public class ArbolesBusquedas 2 3 public static void main(String[] args) 4 // crear nodos5 NodoArbol raiz = new NodoArbol('v');6 7 // primer nivel8 NodoArbol nivel1hijo0 = new NodoArbol('i');9 NodoArbol nivel1hijo1 = new NodoArbol('o');10 NodoArbol nivel1hijo2 = new NodoArbol('r');11 12 // segundo nivel13 NodoArbol nivel2hijo0 = new NodoArbol('d');14 NodoArbol nivel2hijo1 = new NodoArbol('c');15 NodoArbol nivel2hijo2 = new NodoArbol('n');16 NodoArbol nivel2hijo3 = new NodoArbol('r');17 NodoArbol nivel2hijo4 = new NodoArbol('e');18 NodoArbol nivel2hijo5 = new NodoArbol('e');19 20 // tercer nivel21 NodoArbol nivel3hijo0 = new NodoArbol('a');22 NodoArbol nivel3hijo1 = new NodoArbol('s');23 NodoArbol nivel3hijo2 = new NodoArbol('c');24 NodoArbol nivel3hijo3 = new NodoArbol('u');25 NodoArbol nivel3hijo4 = new NodoArbol('n');26 NodoArbol nivel3hijo5 = new NodoArbol('t');27 NodoArbol nivel3hijo6 = new NodoArbol('s');28 29 // construir el arbol30 raiz.addHijo(nivel1hijo0);31 raiz.addHijo(nivel1hijo1);32 raiz.addHijo(nivel1hijo2);33 34 // primer nivel35 nivel1hijo0.addHijo(nivel2hijo0);36 nivel1hijo0.addHijo(nivel2hijo1);37 nivel1hijo1.addHijo(nivel2hijo2);

38 nivel1hijo2.addHijo(nivel2hijo3);

30/05/13 Búsqueda en amplitud y profundidad en árboles | vidasConcurrentes

blog.vidasconcurrentes.com/programacion/busqueda-en-profundidad-y-busqueda-en-anchura/ 4/12

El código de arriba crea el árbol que hemos visto en la figura superior. Todos estamos de acuerdoen que quizá no es la forma elegante de crear el árbol y probablemente existen formas máscortas y eficientes de hacerlo. Sin embargo prefiero mantener la claridad en la explicación paraque no se me pierda nadie.

Lo siguiente que vamos a hacer es crear las búsquedas en anchura y profundidad. Pero antes decrearlas tendremos que saber qué hace cada una, ¿no?

Búsqueda en anchura

La busqueda en anchura (o búsqueda en amplitud), llamada Breadth First Search en inglés, es unalgoritmo usado para recorrer o buscar elementos en una estructura de datos como los árboles ylos grafos (aunque nosotros nos centremos ahora mismo en los árboles). Pertenece al grupo delas búsquedas no informadas (sin heurísticas). Su procedimiento consiste en ir visitando todos losnodos de un nivel antes de proceder con el siguiente nivel tal y como mostramos en la siguientefigura (los números en naranja indican el orden de exploración de los nodos):

De modo que lo primero que hará será visitar la raíz, luego los hijos de la raíz, luego los hijos decada uno de estos hijos y así sucesivamente. ¿Cómo hacemos esto para que funcione, pensaréis?La respuesta es sencilla: usar una cola como estructura de datos auxiliar.

Una cola es una estructura FIFO (First In, First Out) en la que sólo disponemos de dosoperaciones: insertar al final de la cola y extraer del principio de la cola. Por tanto, el elementoque entra el último será el último en salir. Como hemos elegido Java como lenguaje deprogramación para esta entrada, disponemos ya de la interfaz Queue<E> y la clase LinkedList<E>que nos van a brindar la funcionalidad de las colas sin programar nada.

Nuestro procedimiento va a ser el siguiente:

Insertamos la raíz en la cola, como preparación.Si la cola no está vacía, sacamos el primer elemento (el primer nodo que haya en la cola) ycomprobamos si es el elemento que estamos buscando. Si es igual entonces acabamos, sino es igual obtenemos todos los hijos de dicho nodo y los insertamos en la cola(recordamos que las inserciones son por el final).Repetimos hasta que hayamos encontrado el elemento o la cola sea vacía.Finalizamos.

Como la búsqueda se realiza desde un NodoArbol (la raíz), cabe pensar que la función debúsqueda debe ser parte de esta clase. Por tanto, agreamos la siguiente función a la claseNodoArbol:

39 nivel1hijo2.addHijo(nivel2hijo4);40 nivel1hijo2.addHijo(nivel2hijo5);41 42 // segundo nivel43 nivel2hijo0.addHijo(nivel3hijo0);44 nivel2hijo0.addHijo(nivel3hijo1);45 nivel2hijo2.addHijo(nivel3hijo2);46 nivel2hijo2.addHijo(nivel3hijo3);47 nivel2hijo4.addHijo(nivel3hijo4);48 nivel2hijo4.addHijo(nivel3hijo5);49 nivel2hijo5.addHijo(nivel3hijo6);50 51

1 public boolean busquedaAnchura(char c)

30/05/13 Búsqueda en amplitud y profundidad en árboles | vidasConcurrentes

blog.vidasconcurrentes.com/programacion/busqueda-en-profundidad-y-busqueda-en-anchura/ 5/12

Como hemos dicho previamente, lo primero es insertar la raíz en la cola para que tengamos algopor donde empezar. A partir de entonces, si existe algo en la cola cogemos la cabecera (la funciónpoll() devuelve la cabeza y la elimina de la cola). Ahora comprobamos si el elemento interno deeste nodo es el que estamos buscando (recordemos que se debe usar la función .equals() paracomparar objetos no primitivos). Si el elemento es el que buscamos entonces retornamos de lafunción positivamente, si no lo es entonces cogemos todos los hijos de dicho nodo y losinsertamos en la cola para hacer una iteración más.

Llega el momento de probar que lo que hemos hecho funciona como esperamos. Los siguientescódigos se deben insertar al final del main de la clase ArbolesBusquedas y lo que obtendríamosal ejecutar está marcado como output. Comenzamos probando que encontramos la raíz:

Comprobamos que encontramos la letra ‘u’:

Comprobamos que no encontramos la letra ‘z’:

2 Queue<NodoArbol> colaAuxiliar = new LinkedList<NodoArbol>();3 colaAuxiliar.add(this);4 5 while(colaAuxiliar.size() != 0) 6 NodoArbol cabeza = colaAuxiliar.poll();7 System.out.println(cabeza.getElemento()); // solo añadido como

informacion para nosotros8 if(cabeza.getElemento() == c)9 return true;10 else11 for(NodoArbol hijo : cabeza.getHijos())12 colaAuxiliar.add(hijo);13 14 return false;15

1 System.out.println(raiz.busquedaAnchura('v'));2 3 /* output4 v5 true6 */

1 System.out.println(raiz.busquedaAnchura('u'));2 3 /* output4 v5 i6 o7 r8 d9 c10 n11 r12 e13 e14 a15 s16 c17 u18 true19 */

1 System.out.println(raiz.busquedaAnchura('z'));2 3 /* output4 v5 i6 o7 r8 d9 c10 n11 r12 e13 e14 a15 s16 c17 u18 n19 t

30/05/13 Búsqueda en amplitud y profundidad en árboles | vidasConcurrentes

blog.vidasconcurrentes.com/programacion/busqueda-en-profundidad-y-busqueda-en-anchura/ 6/12

¿Qué pasa si buscamos la letra ‘c’? Existen varias letras ‘c’, ¿cuál encontrará? Probemos:

Entonces, la búsqueda en anchura va a encontrar el elemento de menor profundidad del árbol, sies que existe.

Ventajas de la búsqueda en anchura:

Es completo: siempre encuentra la solución si existe.Es óptimo si el coste de cada rama es constante: en Inteligencia Artificial puede que cadanodo sea un estado de un problema, y que unas ramas tengan un coste diferente a lasdemás.

Inconvenientes de la búsqueda en anchura:

Complejidad exponencial en espacio y tiempo (incluso peor la del espacio que la deltiempo).

Búsqueda en profundidad

La busqueda en profundidad, llamada Depth First Search en inglés, es un algoritmo usado pararecorrer o buscar elementos en un árbol o un grafo y pertenece al grupo de las búsquedas noinformadas (sin heurísticas). Su procedimiento consiste en visitar todos los nodos de formaordenada pero no uniforme en un camino concreto, dejando caminos sin visitar en su proceso.Una vez llega al final del camino vuelve atrás hasta que encuentra una bifurcación que no haexplorado, y repite el proceso hasta acabar el árbol (esto se conoce como backtracking). En lasiguiente figura mostramos el orden de visita, siendo los números en naranja dicho orden:

Para poder programar dicho comportamiento vamos a apoyarnos en una estructura de datosllamada pila. Una pila es una estructura de datos LIFO (Last In, First Out) en la que sólodisponemos de dos operaciones: apilar y desapilar. Apilar añade el elemento en la cabeza ydesapilar lo extrae y elimina. Por tanto, el primer elemento que entre se quedará en el fondo yserá el último en visitarse. Igual que con las colas, Java nos brinda la clase Stack<T> que nos va aservir el comportamiento deseado.

Nuestro procedimiento, por tanto, será:

Insertamos la raíz en la pila, para preparación.Mientras haya algo en la pila, desapilamos la cabeza. Comprobamos si es el elemento quebuscamos y si lo es acabamos. Si no lo es, cogemos todos los hijos de dicho nodo y los

20 s21 false22 */

1 System.out.println(raiz.busquedaAnchura('c'));2 3 /* output4 v5 i6 o7 r8 d9 c10 true11 */

30/05/13 Búsqueda en amplitud y profundidad en árboles | vidasConcurrentes

blog.vidasconcurrentes.com/programacion/busqueda-en-profundidad-y-busqueda-en-anchura/ 7/12

apilamos todos.Repetimos hasta que encontremos el elemento buscado o la pila esté vacía.Finalizamos.

Por tanto, añadimos la siguiente función a la clase NodoArbol:

Pregunta: ¿por qué no hemos hecho el bucle for igual que en la búsqueda en anchura?Recordemos que una pila es una estructura en la que lo último que entra es lo primero que sale.Nosotros queremos ir explorando el árbol por el camino de más a la izquieda, tal y comomostrábamos en la figura superior. Si usáramos el mismo bucle for que en la búsqueda enanchura, estaríamos haciendo la búsqueda por la derecha, puesto que el elemento de la cabezade la pila siempre sería el hijo de más a la derecha del nodo consultado.

Comprobemos entonces que funciona. Igual que antes, pondremos los siguientes códigos al finalde la creación del árbol en el main y al ejecutar veremos lo que está marcado como output:

Comprobamos que encuentra la raíz:

Comprobamos que encuentra la letra ‘u’:

Comprobamos que no encuentra la letra ‘z’:

1 public boolean busquedaProfundidad(char c) 2 Stack<NodoArbol> pilaAuxiliar = new Stack<NodoArbol>();3 pilaAuxiliar.push(this);4 5 while(pilaAuxiliar.size() != 0) 6 NodoArbol cabeza = pilaAuxiliar.pop();7 System.out.println(cabeza.getElemento()); // solo añadido como

informacion para nosotros8 if(cabeza.getElemento() == c)9 return true;10 else11 for(int i = cabeza.getHijos().size() 1; i >= 0; i)12 pilaAuxiliar.push(cabeza.getHijos().get(i));13 14 return false;15

1 System.out.println(raiz.busquedaProfundidad('v'));2

3 /* output4 v5 true6 */

1 System.out.println(raiz.busquedaProfundidad('u'));2 3 /* output4 v5 i6 d7 a8 s9 c10 o11 n12 c13 u14 true15 */

1 System.out.println(raiz.busquedaProfundidad('z'));2 3 /* output4 v5 i6 d7 a8 s9 c10 o11 n12 c13 u14 r

30/05/13 Búsqueda en amplitud y profundidad en árboles | vidasConcurrentes

blog.vidasconcurrentes.com/programacion/busqueda-en-profundidad-y-busqueda-en-anchura/ 8/12

¿Qué pasa si buscamos la letra ‘c’?

Como vemos, la búsqueda en profundidad busca el elemento por el camino de máximaprofundidad y cuando éste se acaba, vuelve al último nodo que había visitado con caminosposibles (caminos abiertos).

Ventajas de la búsqueda en profundidad:

Es completa si no existen ciclos repetidos.Tiene menor complejidad en espacio que la búsqueda en anchura, porque solomantenemos en memoria un camino simultáneamente.

Inconvenientes de la búsqueda en profundidad:

No es óptima.Puede no encontrar la solución aunque exista si hay caminos infinitos. Luego no escompleta.

Quizá el ejemplo anterior no sea demasiado ilustrativo para el caso de la letra ‘c’. Veamos elsiguiente árbol, que está simplificado pero nos ayudará a entenderlo mejor:

Ahora veamos qué pasa si buscamos con ambos algoritmos el elemento cuyo carácter es una ‘c’.

Comenzamos con la búsqueda en anchura:

15 r16 e17 n18 t19 e20 s21 false22 */

1 System.out.println(raiz.busquedaProfundidad('c'));2 3 /* output4 v5 i6 d7 a8 s9 c10 true11 */

30/05/13 Búsqueda en amplitud y profundidad en árboles | vidasConcurrentes

blog.vidasconcurrentes.com/programacion/busqueda-en-profundidad-y-busqueda-en-anchura/ 9/12

Ahora la búsqueda en profundidad:

¿Qué vemos aquí? La búsqueda en anchura ha visitado sólo 3 nodos hasta encontrar la soluciónmientras que la búsqueda en profundidad ha visitado 11 nodos para encontrar la suya. ¿Significaesto que la búsqueda en anchura es mejor que la búsqueda en profundidad? Miremos un últimoejemplo:

Buscamos el elemento cuyo carácter es ‘c’ y los dos recorridos serán los que se ven en lasiguiente figura (click para agrandar):

¿Y ahora? ¿Cuál es mejor? Parece que la búsqueda en profundidad.

Concluiremos con que en realidad no hay una búsqueda no informada mejor o peor, porquedependen mucho de la posición de nuestra solución dentro del árbol (entendemos solución porlo que estamos buscando). ¿Cómo solucionamos esto, entonces? La respuesta es usar búsquedasinformadas (usando heurísticas). Sin embargo es un campo muy amplio y en esta entrada novamos a tratarlo.

Por tanto, podemos generalizar el algoritmo que usaremos en dichas búsquedas como lo

30/05/13 Búsqueda en amplitud y profundidad en árboles | vidasConcurrentes

blog.vidasconcurrentes.com/programacion/busqueda-en-profundidad-y-busqueda-en-anchura/ 10/12

Like 12 0 TwittearTwittear 11

← Rogue AP con karmetasploit Obteniendo información de dispositivos Androidcon Metasploit →

siguiente:

Donde la lista abierta podemos generalizarla como una lista enlazada simple y el orden deinserción es al inicio, al final u otro lugar dependiendo de la búsqueda que estemos haciendo. Deesta forma tendríamos una forma general de realizarlas. Si esto fuera Ingeligencia Artificial y nouna simple búsqueda de un elemento, cabria añadir una instrucción más por cada sucesor yademás devolver el nodo una vez encontrado, y no un valor booleano.

Algunos usos de las búsquedas

Antes de acabar voy a hablar muy brevemente sobre las aplicaciones de estas búsquedas.

La aplicación básica es la de encontrar un elemento en concreto dentro de nuestra estructura dedatos, como hemos visto.

Por su parte, la Inteligencia Artificial trata de, dado un problema, hayar su solución. Supongamosun laberinto. Nuestro agente inteligente debe encontrar la salida. Si esta búsqueda de la salida larealiza con búsquedas no informadas (sin heurísticas) puede acabar en ciclos infinitos (en caso dela búsqueda en profundidad) o tardar muchísimo tiempo (en la búsqueda en anchura siempreencontramos la solución más corta si existe, pero esto puede ser en la parte inferior derecha delárbol, que es lo último en visitar). También existen modificaciones de dichos algoritmos como labúsqueda en profundidad limitada (para evitar ciclos infinitos).

Para solventar estos problemas surgieron las búsquedas informadas que usan heurísticas. Éstas,antes de explorar un nuevo nodo evaluan cuál de los hijos le ofrece mayor recompensa. Estaforma de decidir qué nodo es mejor depende de la heurística usada, que pueden ser muy variadase incluso ineficientes.

Por ejemplo la heurística lo que más me acerque a la meta puede parecer una gran idea. Peropuede traer un inconveniente: ¿y si hay una pared desde donde estoy hasta la meta? Sí, mequeda una casilla para llegar, ¡pero no puedo atravesar el muro!

Esto es solamente un ejemplo y haría falta mucha explicación para cubrir los casos y sobre todohacer una comparativa en complejidad espacial y temporal de cada una de las búsquedas. Sinembargo como idea inicial de posibles usos de las búsquedas vistas durante la entrada essuficiente.

¡Espero que haya sido de utilidad para los lectores!

Esta entrada fue publicada en Esta entrada fue publicada en ProgramaciónProgramación y etiquetada como y etiquetada como algoritmoalgoritmo, , amplitudamplitud, , anchuraanchura,,arbolarbol, , arbol de busquedaarbol de busqueda, , bfsbfs, , breadth first searchbreadth first search, , busquedabusqueda, , colacola, , depth first searchdepth first search, , dfsdfs,,estructuras de datosestructuras de datos, , grafosgrafos, , javajava, , pilapila, , profundidadprofundidad..

4 Respuestas a Búsqueda en anchura y búsqueda en profundidadpara árboles

1 listaAbierta < raiz2 REPETIR3 SI esVacia(listaAbierta) ENTONCES4 DEVOLVER(negativo)5 6 nodo < primero(listaAbierta)7 SI esNodoMeta(nodo) ENTONCES8 DEVOLVER(positivo)9 10 listaSucesores < expandir(nodo)11 PARA CADA n : sucesores HACER12 insertar(n, listaAbierta, ordenInsercion)13 FIN

ShareShare 1

30/05/13 Búsqueda en amplitud y profundidad en árboles | vidasConcurrentes

blog.vidasconcurrentes.com/programacion/busqueda-en-profundidad-y-busqueda-en-anchura/ 11/12

1. LuismiLuismi dijo:dijo:16 septiembre, 2011 at 10:3016 septiembre, 2011 at 10:30

Muy bien explicado la verdad, creo que se entiende fácilmente.Por cierto, creo que tienes un error en la numeración del ejemplo de búsqueda enprofundidad (letras n, r, t)

Saludos!

Responder

metameta dijo:dijo:16 septiembre, 2011 at 13:4416 septiembre, 2011 at 13:44

Tienes razón, había una errata en la numeración de la búsqueda en profundidad. ¡Yaestá solucionado!

¡Muchas gracias!

Responder

2. hdfc bank netbankinghdfc bank netbanking dijo:dijo:30 marzo, 2012 at 2:5130 marzo, 2012 at 2:51

Keep the religion, my Online companion. You are a first-class author and deserve for beinglistened to.

Responder

3. kx27kx27 dijo:dijo:29 julio, 2012 at 22:3729 julio, 2012 at 22:37

muchas gracias, esta muy bien explicado, creo que hasta mejor que mi profe

Responder

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos necesarios están marcados *

Nombre *

Correo electrónico *

Web

Comentario

Puedes usar las siguientes etiquetas y atributos HTML:<a href="" title=""> <abbr title=""> <acronym title=""> <b>

30/05/13 Búsqueda en amplitud y profundidad en árboles | vidasConcurrentes

blog.vidasconcurrentes.com/programacion/busqueda-en-profundidad-y-busqueda-en-anchura/ 12/12

vidasConcurrentesvidasConcurrentesSitio creado por Sitio creado por metameta y y sshMansshMan

<blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <qcite=""> <strike> <strong>

Publicar comentario

RT @AlbertoHachkerAlbertoHachker: Los chicos de @vidasConcurrentvidasConcurrent semerecen un monumento! Su curso de introducción paraAndroid es de lo mejorcito! Fu ... hace 256 diashace 256 dias

Escribe las dos palabras