Algoritmos y Estructuras de Datos Algoritmos y Estructuras de Datos

Algoritmos y Estructuras de Datos
Cursada 2021
Prof. Alejandra Schiavoni (ales@info.unlp.edu.ar)
Prof. Catalina Mostaccio (catty@lifia.info.unlp.edu.ar)
Prof. Laura Fava (lfava@info.unlp.edu.ar)
Prof. Pablo Iuliano (piuliano@info.unlp.edu.ar)

Árboles Binarios
Árboles Binarios
Prof. Alejandra Schiavoni – Prof. Catalina Mostaccio Algoritmos y Estructuras de Datos 2021
Agenda
 Definición
 Descripción y terminología
 Representaciones
 Recorridos
 Aplicación: Árboles de expresión
Árbol Binario: Definición
Un árbol binario es una colección de nodos, tal
que:
• puede estar vacía
• puede estar formada por un nodo distinguido R,
llamado raíz y dos sub-árboles T1 y T2, donde la
raíz de cada subárbol Ti está conectado a R por
medio de una arista
Descripción y terminología
Cada nodo puede tener a lo sumo dos nodos hijos.
Cuando un nodo no tiene ningún hijo se denomina
hoja.
Los nodos que tienen el mismo nodo padre se
denominan hermanos.
 Conceptos a usar:
• Camino: desde n1 hasta nk, es una secuencia de nodos n1,
n2, ….,nk tal que ni es el padre de ni+1, para 1 ≤ i < k.
• La longitud del camino es el número de aristas, es decir k-1.
• Existe un camino de longitud cero desde cada nodo a sí mismo.
• Existe un único camino desde la raíz a cada nodo.
• Profundidad: de ni es la longitud del único camino desde la raíz

hasta ni.
• La raíz tiene profundidad cero.
• Grado de ni es el número de hijos del nodo ni .
• Altura de ni es la longitud del camino más largo desde ni hasta

una hoja.
• Las hojas tienen altura cero.
• La altura de un árbol es la altura del nodo raíz.
• Ancestro/Descendiente: si existe un camino desde n1 a n2, se

dice que n1 es ancestro de n2 y n2 es descendiente de n1.
Profundidad(8) = 2
Altura(5) = 1 ¿Cuál es la altura del nodo 8?

¿Cuál es la profundidad del nodo 12?
¿Cuáles son los ancestros del nodo 11?
Profundidad(8) = 2
Altura(5) = 1 ¿Cuál es la altura del nodo 8? 2

¿Cuál es la profundidad del nodo 12? 2
¿Cuáles son los ancestros del nodo 11? 7 y 4
• Árbol binario lleno: Dado un árbol binario T de altura h,
diremos que T es lleno si cada nodo interno tiene grado 2
y todas las hojas están en el mismo nivel (h).
Es decir, recursivamente, T es lleno si :

1.- T es un nodo simple (árbol binario lleno de altura 0), o
2.- T es de altura h y sus sub-árboles son llenos de altura
h-1.
• Cantidad de nodos en un árbol binario lleno:
Sea T un árbol binario lleno de altura h, la cantidad de nodos
N es (2 h+1 – 1)
N es (2 h+1 – 1)
… … … … … ….
N es (2 h+1 – 1)
Nivel 0  20 nodos
h
……
… … … … … ….
Nivel h  2h nodos
N es (2 h+1 – 1)
Nivel 1  21 nodos N = 20 + 21 + 22 + 23+…+2h
h
Nivel 2  22 nodos La suma de los términos de
Nivel 3  23 nodos una serie geométrica de razón
2 es:
…… (2 h+1 – 1)
… … … … … ….
Nivel h  2h nodos
• Árbol binario completo: Dado un árbol binario T de altura h,
diremos que T es completo si es lleno de altura h-1 y el nivel h
se completa de izquierda a derecha.
• Cantidad de nodos en un árbol binario completo:

Sea T un árbol binario completo de altura h, la cantidad de
nodos N varía entre (2 h ) y (2 h+1 – 1)


h-1
h

h-1 • Si el árbol es lleno
h N = (2h+1-1)

h-1 • Si el árbol es lleno
h N = (2h+1-1)
• Si no, el árbol es lleno en la altura h-1 y tiene por lo menos un nodo en el nivel h:
N = (2h-1+1-1)+1=(2h -1 + 1)
Representación
Hijo Izquierdo - Hijo Derecho
 Cada nodo tiene:

• Información propia del nodo
• Referencia a su hijo izquierdo
• Referencia a su hijo derecho
Representación
Hijo Izquierdo - Hijo Derecho
A
A
B C
B C
D
E
E D G H
G H
Recorridos
 Preorden
Se procesa primero la raíz y luego sus hijos, izquierdo y
derecho.
 Inorden
Se procesa el hijo izquierdo, luego la raíz y último el hijo
derecho
 Postorden
Se procesan primero los hijos, izquierdo y derecho, y luego la
raíz
 Por niveles
Se procesan los nodos teniendo en cuenta sus niveles,
primero la raíz, luego los hijos, los hijos de éstos, etc.
Recorrido: Preorden
public void preorden() {
imprimir (dato);
si (tiene hijo_izquierdo)
hijoIzquierdo.preorden();
si (tiene hijo_derecho)
hijoDerecho.preorden();
}
Recorrido: Por niveles
public void porNiveles() {
encolar(raíz);
mientras (cola no se vacíe) {
desencolar(v);
imprimir (dato de v);
si (tiene hijo_izquierdo)
encolar(hijo_izquierdo);
si (tiene hijo_derecho)
encolar(hijo_derecho);
}
}
Ejercitación Árbol binario: Recorridos
Ejercicio 1
b) 3
a) 7
7
9 8
8 9
10 11
10 11 18
c) 8
10
13 15
Ejercicio 1
b) 3
a) 7 a)
7
inorden : 10 9 11 7 8
9 8
postorden : 10 11 9 8 7 8 9
10 11 preorden: 7 9 10 11 8
10 11 18
c) 8
10
13 15
Ejercicio 1
b) 3
a) 7 a)
7
inorden : 10 9 11 7 8
9 8
postorden : 10 11 9 8 7 8 9
10 11 preorden: 7 9 10 11 8
10 11 18
b)
c) 8
inorden : 3 10 8 11 7 9 18
10 postorden : 10 11 8 18 9 7 3
preorden: 3 7 8 10 11 9 18
13 15
Ejercicio 1
b) 3
a) 7 a)
7
inorden : 10 9 11 7 8
9 8
postorden : 10 11 9 8 7 8 9
10 11 preorden: 7 9 10 11 8
10 11 18
b)
c) 8 c)
inorden : 3 10 8 11 7 9 18
inorden : 13 10 15 8
10 postorden : 10 11 8 18 9 7 3
postorden : 13 15 10 8
preorden: 3 7 8 10 11 9 18
13 15 preorden: 8 10 13 15
Ejercicio 1
b) 3
a) 7 a)
7
inorden : 10 9 11 7 8
9 8
postorden : 10 11 9 8 7 8 9
10 11 preorden: 7 9 10 11 8
10 11 18
b)
c) 8 c)
inorden : 3 10 8 11 7 9 18
inorden : 13 10 15 8
10 postorden : 10 11 8 18 9 7 3
postorden : 13 15 10 8
preorden: 3 7 8 10 11 9 18
13 15 preorden: 8 10 13 15
Ejercicio 2
Construya el árbol binario a partir del cual se obtuvieron los siguientes recorridos:
inorden: C B F E G A D I H y postorden: C F G E B I H D A
Ejercicio 2.
inorden : C B F E G A D I H y postorden : C F G E B I H D A
Resolución:
¿Por dónde empezamos?

¿Qué información podemos obtener de los recorridos dados?
¿De qué estamos seguros?
Ejercicio 2.
Resolución:
Raíz
¿ Cómo seguimos ? A
Ejercicio 2.
Resolución:
Raíz
¿Cómo armamos los subárboles? A

¿Qué información podemos
obtener de los recorridos dados?
¿sub. izq.? ¿sub. der.?
Ejercicio 2.
Resolución:
Raíz
sub. izq. sub. der.
A
¿Cómo están distribuidos los datos?

¿Cuáles son las raíces de los subárboles?
Ejercicio 2.
Resolución:
Raíz
sub. izq. sub. der.
A
¿Cómo están distribuidos los datos?

¿Cuáles son las raíces de los subárboles?
Ejercicio 2.
Resolución:
sub. izq. sub. der.

A
B D
Repetimos los pasos anteriores y …
Ejercicio 2.
Resolución:
A
B D
C H
E
F G I
Árbol de Expresión
Es un árbol binario asociado a una expresión
aritmética
 Nodos internos representan operadores
 Nodos externos (hojas) representan operandos
Ejemplo:
/
* +
e f
+ -
a b c d
Aplicaciones:
 En compiladores para analizar, optimizar y traducir

programas
 Evaluar expresiones algebraicas o lógicas
• No se necesita el uso de paréntesis
 Traducir expresiones a notación sufija, prefija e infija
/
Recorriendo el árbol, obtenemos:
* +
e f
+ -
a b c d
Inorden: (((a + b) * (c – d)) / (e + f))
Preorden: /*+ab-cd+ef
Postorden: ab+cd-*ef+/
Construcción de un árbol de expresión
A partir de una:
1) Expresión postfija -
2 +
2) Expresión prefija * 5
3 4
3) Expresión infija
Árboles binarios de expresión
Expresión algebraica :
a*( b*d +c) + ( e+ f*g )

+
* +
+ e
*
a * c
f g
b d
Expresión prefija +*a+*b d c+ e *f g

Expresión postfija abd*c+* e f g*+ +
Expresión infija ((a *(( b * d) + c)) + (e + (f * g)))
1) Construcción de un árbol de expresión a partir de
una expresión postfija
Algoritmo:
tomo un carácter de la expresión

mientras ( existe carácter ) hacer
si es un operando  creo un nodo y lo apilo.
si es un operador (lo tomo como la raíz de los dos últimos nodos creados)
 - creo un nodo R,
- desapilo y lo agrego como hijo derecho de R
- desapilo y lo agrego como hijo izquierdo de R
- apilo R.
tomo otro carácter
fin
Expresión postfija: a b d * c + * e f g * + + +
Algoritmo:
* +
si es un operando  creo un nodo y lo apilo. + e
si es un operador (lo tomo como la raíz de los dos últimos nodos creados) *
a * c
b f g
- apilo R.
d
tomo otro carácter
fin
abd*c+* e f g*+ +
a
P1
P1
Algoritmo:
* +
a * c
b f g
- apilo R.
d
tomo otro carácter
fin
abd*c+* e f g*+ +
a
P2 P1 b
P1
P2
Algoritmo:
* +
a * c
b f g
- apilo R.
d
tomo otro carácter
fin
abd*c+* e f g*+ +
P3 a
P2 P1 b d
P1
P2 P3
Algoritmo:
* +
a * c
b f g
- apilo R.
d
tomo otro carácter
fin
abd*c+* e f g*+ +
R1
P3 a *
P2 P1 b d
P1
P2 P3
Algoritmo:
* +
a * c
b f g
- apilo R.
d
tomo otro carácter
fin
abd*c+* e f g*+ +
R1
a *
P2 P3 P1 b d
P1
P2 P3
Algoritmo:
* +
a * c
b f g
- apilo R.
d
tomo otro carácter
fin
abd*c+* e f g*+ +
R1
a *
P2
P1 b d
P1
P2 P3
Algoritmo:
* +
a * c
b f g
- apilo R.
d
tomo otro carácter
fin
abd*c+* e f g*+ +
R1
a *
R1
P1 b d
P1
P2 P3
Algoritmo:
* +
a * c
b f g
- apilo R.
d
tomo otro carácter
fin
abd*c+* e f g*+ +
R1
P4 a * c
R1
P1 b d P4
P1
P2 P3
Algoritmo:
* +
a * c
b f g
- apilo R.
d
tomo otro carácter
fin
abd*c+* e f g*+ +
P4 R2
+
R1
a * c
R1
P1 b d P4
P1
P2 P3
Algoritmo:
* +
a * c
b f g
- apilo R.
d
tomo otro carácter
fin
abd*c+* e f g*+ +
R1 R2
+
R1
a * c
P1 b d P4
P1
P2 P3
Algoritmo:
* +
a * c
b f g
- apilo R.
d
tomo otro carácter
fin
abd*c+* e f g*+ +
R2
+
R1
a * c
R2 P1 b d P4
P1
P2 P3
Algoritmo:
* +
a * c
b f g
- apilo R.
d
tomo otro carácter
fin
abd*c+* e f g*+ + R3
* R2
+
R1
a * c
R2 P1 b d P4
P1
P2 P3
Algoritmo:
* +
a * c
b f g
- apilo R.
d
tomo otro carácter
fin
R2
* R2
P1 +
R1
a * c
P1 b d P4
R3
P2 P3
Algoritmo:
* +
a * c
b f g
- apilo R.
d
tomo otro carácter
fin
* R2
+
R1
a * c
P1 b d P4
R3
P2 P3
Algoritmo:
* +
a * c
b f g
- apilo R.
d
tomo otro carácter
fin
R6
+
* R2
+
+ e
R1 *
a * c
b f g
P1 d P4
R6
P2 P3
una expresión prefija
Algoritmo:
ArbolExpresión (A: ArbolBin, exp: string )
si exp nulo  nada.

si es un operador  - creo un nodo raíz R
- ArbolExpresión (subArbIzq de R, exp
(sin 1 carácter) )
- ArbolExpresión ( subArbDer de R, exp
(sin 1 carácter) )
si es un operando  creo un nodo (hoja)
una expresión infija
Expresión infija 2+5*3+1

Se usa una pila y se tiene en
(i) cuenta la precedencia
de los operadores
Expresión postfija 253*+1+
una expresión infija
Expresión infija 2+5*3+1

Se usa una pila y se tiene en
(i) cuenta la precedencia
de los operadores
Expresión postfija 253*+1+
(ii) Se usa la estrategia 1)
-Convertir una expresión infija en árbol de expresión: se debe
convertir la expresión infija en postfija (i) y a partir de ésta,
construir el árbol de expresión (ii).
(i) Estrategia del Algoritmo para convertir exp. infija en postfija :
a) si es un operando  se coloca en la salida.

b) si es un operador  se maneja una pila según la prioridad del
operador en relación al tope de la pila
operador con > prioridad que el tope –> se apila

operador con <= prioridad que el tope –> se desapila elemento
colocándolo en la salida.
Se vuelve a comparar el operador con el tope de la pila
c) si es un “(“ , “)” “(“ se apila

“)” se desapila todo hasta el “(“, incluído éste
d) cuando se llega al final de la expresión, se desapilan todos los elementos

llevándolos a la salida, hasta que la pila quede vacía.
Operadores ordenados de mayor a menor según su
prioridad:
˄ (potencia)
*, / (multiplicación y división)
+, - (suma y resta)
Los “ ( “ siempre se apilan como si tuvieran la mayor

prioridad y se desapilan sólo cuando aparece un “ ) ” .
Ejercitación
Árbol binario de expresión
Ejercicio 1.
Dada la siguiente expresión postfija : I J K + + A B * C - * , dibuje su
correspondiente árbol binario de expresión
Convierta la expresión ((a + b) + c * (d + e) + f ) * (g + h) en expresión prefija
Ejercicio 2.
Dada la siguiente expresión prefija : * + I + J K - C * A B , dibuje su
correspondiente árbol binario de expresión
Convierta la expresión ((a + b) + c * (d + e) + f ) * (g + h) en expresión postfija
Arboles Generales
Estructura
Algoritmos y Estructuras de Datos 2021 Prof: Laura Fava - Pablo Iuliano

Arboles Generales
Código Fuente – Constructores, this()
package tp04.ejercicio1;
public class ArbolGeneral<T> { public void agregarHijo(ArbolGeneral<T> unHijo) {

private T dato; this.getHijos().agregarFinal(unHijo);
private ListaGenerica<ArbolGeneral<T>> hijos = }
new ListaEnlazadaGenerica<T>();
public void eliminarHijo(ArbolGeneral<T> hijo) {
public ArbolGeneral(T dato) { if (this.tieneHijos()) {
this.dato = dato; Constructores
ListaGenerica<ArbolGeneral<T>> hijos=this.getHijos();
} if (hijos.incluye(hijo))
public ArbolGeneral(T dato, ListaGenerica<ArbolGeneral<T>> hijos){ hijos.eliminar(hijo);
this(dato); }
this.hijos = hijos;
} public boolean esHoja() {
return !this.tieneHijos();
public T getDato() { }
return dato;
} public boolean tieneHijos() {
return this.hijos != null && !this.hijos.esVacia();
public void setDato(T dato) { }
this.dato = dato;
} public boolean esVacio() {
return this.dato == null && !this.tieneHijos();
public void setHijos(ListaGenerica<ArbolGeneral<T>> hijos) { }
if (hijos==null) }
hijos=new ListaEnlazadaGenerica<T>();
this.hijos = hijos;
}
public ListaGenerica<ArbolGeneral<T>> getHijos() {

return this.hijos;
}

Arboles Generales
Recorrido PreOrden
Implementar un método en ArbolGeneral que retorne imprima los valores en preorden. recorrido en preorden
package ayed;
public class ArbolGeneral<T> {
private T dato;
private ListaGenerica<ArbolGeneral<T>> hijos;
. . .
public void pre_Orden() {
System.out.println(this.getDato());
ListaGenerica<ArbolGeneral<T>> lHijos = this.getHijos();
lHijos.comenzar();
while (!lHijos.fin()) {
(lHijos.proximo()).pre_Orden();
}
}
}
Fragmento de código que crea un árbol general e invoca el recorrido pre_Orden() (puede ser una main en una clase de test)
ArbolGeneral<String> a1 = new ArbolGeneral<String>("1");
ListaGenerica<ArbolGeneral<String>> hijos = new ListaEnlazadaGenerica<ArbolGeneral<String>>();
hijos.agregarFinal(a1); hijos.agregarFinal(a2); hijos.agregarFinal(a3);
ArbolGeneral<String> a = new ArbolGeneral<String>("0", hijos);
ListaGenerica<ArbolGeneral<String>> hijos_a1 = new ListaEnlazadaGenerica<ArbolGeneral<String>>();
hijos_a1.agregarFinal(a11); hijos_a1.agregarFinal(a12);
a1.setHijos(hijos_a1);
System.out.println("Datos en preorden: "+a.pre_Orden());

Arboles Generales
Recorrido PreOrden
Implementar un método en ArbolGeneral que retorne una lista con los datos del árbol recorrido en preorden
package ayed;
private T dato;
. . .
public ListaEnlazadaGenerica<T> preOrden() {
ListaEnlazadaGenerica<T> lis = new ListaEnlazadaGenerica<T>();
this.preOrden(lis);
return lis;
}
private void preOrden(ListaGenerica<T> l) {
l.agregarFinal(this.getDato());
ListaGenerica<ArbolGeneral<T>> lHijos = this.getHijos();
lHijos.comenzar();
while (!lHijos.fin()) { Fragmento de código que crea un árbol general e invoca el
(lHijos.proximo()).preOrden(l); recorrido preOrden() (puede ser una main en una clase de
} test)
} ArbolGeneral<String> a1 = new ArbolGeneral<String>("1");
} ArbolGeneral<String> a2 = new ArbolGeneral<String>("2");
ListaGenerica<ArbolGeneral<String>> hijos = new ListaEnlazadaGenerica<ArbolGeneral<String>>();
hijos.agregarFinal(a1); hijos.agregarFinal(a2); hijos.agregarFinal(a3);
ArbolGeneral<String> a = new ArbolGeneral<String>("0", hijos);
ListaGenerica<ArbolGeneral<String>> hijos_a1 = new ListaEnlazadaGenerica<ArbolGeneral<String>>();
hijos_a1.agregarFinal(a11); hijos_a1.agregarFinal(a12);
a1.setHijos(hijos_a1);
System.out.println("Datos en preorden: "+a.preOrden());

Arboles Generales
Contar sus hojas
package tp03.ejercicio10;

private T dato;
. . .
/**
* Contar las hojas del arbol general
*/
public int contarHojas() {
if (this.esHoja())
return 1;
else {
int cont = 0;
ListaGenerica<ArbolGeneral2<T>> lista = this.getHijos();
lista.comenzar();
while (!lista.fin()) {
ArbolGeneral2<T> arbol = lista.proximo();
cont = cont + arbol.contarHojas();
}
return cont;
}
}

Arboles Generales
Ejercicio de parcial – Encontrar a la Princesa
Animal
Dado un árbol general compuesto por personajes, donde Coyote
puede haber dragones, princesas y otros, se denominan Animal
Scooby Animal
nodos accesibles a aquellos nodos tales que a lo largo del Dragón Cid
Animal
camino del nodo raíz del árbol hasta el nodo (ambos Negro
Tweety
inclusive) no se encuentra ningún dragón. Princesa Princesa
Cenicienta Dragón Animal La Bella
Rojo Pluto
Implementar un método que devuelva una lista con un camino desde la raíz a una Princesa sin
pasar por un Dragón –sin necesidad de ser el más cercano a la raíz-. Asuma que existe al menos un
camino accesible.

Arboles Generales
package parcial.juego;
public class Personaje {

private String nombre;
private String tipo; //Dragon, Princesa, Animal, etc.
public Personaje(String nombre, String tipo) {

this.nombre = nombre;
this.tipo = tipo; Animal
} Coyote
public String getNombre() { Animal
return nombre; Scooby Animal
} Dragón Cid
Animal
public void setNombre(String nombre) { Negro
Tweety
this.nombre = nombre; Princesa
Princesa
} Cenicienta Dragón Animal La Bella
. . . Rojo Pluto
public boolean esDragon(){

return this.getTipo().equals("Dragon");
}
public boolean esPrincesa(){
return this.getTipo().equals("Princesa");
}
}

Animal
Arboles Generales Animal
Coyote
Animal
Ejercicio de parcial – Encontrar a la Princesa Scooby
Cid
Dragón
Versión I Negro
Animal
Tweety
public class Juego { Princesa Princesa
Cenicienta Dragón A ni m al La Bella
Rojo P luto
public void encontrarPrincesa(ArbolGeneral<Personaje> arbol) {
ListaGenerica<Personaje> lista = new ListaEnlazadaGenerica<Personaje>();
lista.agregarInicio(arbol.getDato());
ListaGenerica<Personaje> camino = new ListaEnlazadaGenerica<Personaje>();
encontrarPrincesa(arbol, lista, camino);
System.out.print("Se encontró a la Princesa en el camino: " + camino);
}
private void encontrarPrincesa(ArbolGeneral<Personaje> arbol, ListaGenerica<Personaje> lista,
ListaGenerica<Personaje> camino) {
Personaje p = arbol.getDato();
if (p.esPrincesa()) {
clonar(lista, camino);
}
if (camino.esVacia()) {
ListaGenerica<ArbolGeneral<Personaje>> lHijos = arbol.getHijos();
lHijos.comenzar();
while (!lHijos.fin() && camino.esVacia()) {
ArbolGeneral<Personaje> aux = lHijos.proximo();
if (!aux.getDato().esDragon()) { public void clonar(L
istaGenerica<Persona
lista.agregarFinal(aux.getDato()); je> origen,
ListaGenerica<Person
encontrarPrincesa(aux, lista, camino); origen.comenzar(); aj e> destino) {
lista.eliminarEn(lista.tamanio()); while (!origen.fin()
) {
} destino.agregarFinal
(origen.proximo());
} }
} }
}
}
Arboles Generales
Versión II
public class Juego {
public ListaEnlazadaGenerica<Personaje> encontrarPrincesa(ArbolGeneral<Personaje> arbol){

ListaEnlazadaGenerica<Personaje> lista = new ListaEnlazadaGenerica<Personaje>();
if (arbol.getDato().esPrincesa() || arbol.getDato().esDragon() || arbol.esHoja()){
if (arbol.getDato().esPrincesa()){
Personaje p = arbol.getDato();
lista.agregarInicio(p);
}
return lista;
}
ListaGenerica<ArbolGeneral<Personaje>> lHijos = arbol.getHijos();
lHijos.comenzar();
while(!lHijos.fin() && lista.esVacia()){
lista = encontrarPrincesa(lHijos.proximo());
if(!lista.esVacia()){
Animal
lista.agregarInicio(arbol.getDato()); Coyote
//break; en vez de lista.esVacia() en el while Anim
al
} Scooby Animal
} Dragón Cid
Animal
return lista; Negro
Tweety
}
Princesa Princesa
} Animal
Cenicienta Dragón La Bella
} Pluto
Rojo

Arboles Generales
package parcial.juego;
…
public class JuegoTest { Animal
public static void main(String[] args) { Coyote
Personaje p0 = new Personaje("Scooby", "Animal"); Animal
Personaje p1 = new Personaje("Cenicienta", "Princesa"); Scooby Animal
Personaje p2 = new Personaje("Rojo", "Dragon"); Dragón Cid
Personaje p3 = new Personaje("Pluto", "Animal"); Animal
Negro
Personaje p4 = new Personaje("Negro", "Dragon"); Tweety
Personaje p5 = new Personaje("La Bella", "Princesa"); Princesa Princesa
Cenicienta Dragón A nim al La Bella
Personaje p6 = new Personaje("Tweety", "Animal");
Personaje p7 = new Personaje("Cid", "Animal"); Rojo P luto
Personaje p8 = new Personaje("Coyote", "Animal");
ArbolGeneral<Personaje> a1 = new ArbolGeneral<Personaje>(p0);
ListaGenerica<ArbolGeneral<Personaje>> hijosa2 = new ListaEnlazadaGenerica<ArbolGeneral<Personaje>>();
hijosa2.agregarFinal(a21);
ArbolGeneral<Personaje> a2 = new ArbolGeneral<Personaje>(p4, hijosa2);
. . .
ArbolGeneral<Personaje> a = new ArbolGeneral<Personaje>(p8, hijos);
Juego juego = new Juego();
juego.encontrarPrincesa(a);
}
}

Arboles Generales
Ejercicio de parcial
Antiguamente el pueblo judío usaba un sistema de numeración llamado Gematria para asignar valores
a las letras y así “ocultar” nombres, de aquí que se asocia el nombre de Nerón César al valor 666 (la
suma de los valores de sus letras).
Usted cuenta con una estructura como la que aparece en el gráfico, donde cada camino en este
árbol representa un nombre. Cada nodo contiene un valor asociado a una letra, excepto el nodo
raíz que contiene el valor 0 y no es parte de ningún nombre, y simplemente significa “comienzo”. “Un
nombre completo SIEMPRE es un camino que comienza en la raíz y termina en una hoja.”
Su tarea será: dado un valor numérico, contar
cuantos nombres completos suman exactamente ese
valor. Usted recibe el árbol con las letras ya sustituidas
por sus valores; las letras ya no importan.
Para esto, unaescriba

clase llamada
ProcesadorGematria (que NO contenga variables
de instancia), con sólo un método público con la
siguiente firma:
public int contar(xxx, int valor)
estructura que contiene valor es el valor que se debería

los números obtener al sumar el valor de las
letras de un nombre

Arboles Generales
Ejercicio de parcial
public class Gematria {
public static int contadorGematria(ArbolGeneral<Integer> ag, int valor) {
int resta = valor - ag.getDato();
if (ag.esHoja() && resta == 0)
return 1;
else {
int cont = 0;
ListaGenerica<ArbolGeneral<Integer>> lista = ag.getHijos();
lista.comenzar();
while (!lista.fin()) {
ArbolGeneral<Integer> arbol = lista.proximo();
if (resta > 0)
cont = cont + contadorGematria(arbol, resta);
}
return cont;
}
}
}

Arboles Generales
Ejercicio de parcial - Quadtree
Un quadtree es una representación usada para cubrir un espacio cuadrado en dos
dimensiones y posteriormente utilizado para determinar ciertas condiciones entre
objetos en el mismo.
Un artista moderno trabaja con imágenes codificadas en quadtree’s. El quadtree es

un árbol 4-ario que codifica a una imagen con el siguiente criterio:
-Si toda la imagen tiene un mismo color, la misma es representada por un único
nodo que almacene un dato que represente a ese color.
-En caso contrario, se divide la imagen en cuatro cuadrantes que se representan en

el árbol como un nodo con 4 hijos, y cada hijo es la conversión de cada una de las
partes de la imagen.
El artista desea saber cuántos pixeles de color negro posee una imagen dada. Usted
debe implementar un método, que dado un quadtree y una cantidad total de pixeles,
cuente cuantos pixeles de color negro contiene la imagen codificada en él.
Algoritmos y Estructuras de Datos–2021 Prof: Fava - Iuliano

Arboles Generales

Arboles Generales
package parcial.quadtree;
Ejercicio de parcial – Quadtree
public class Pixel {
private String color; // Blanco, Negro, Mixto.
public Pixel(String color) {

this.color = color;
}
public String getColor() {

return color;
}
public void setColor(String color) {

this.color = color;
}
public boolean esNegro() {

return this.color.equals("Negro");
}
public boolean esBlanco() {

return this.color.equals("Blanco");
}
}
Arboles Generales
package parcial.quadtree; Ejercicio de parcial – Quadtree
public class CuentaPixels {
. . . .
public static void main(String[] args) {
Pixel p0 = new Pixel("Blanco");

Pixel p3 = new Pixel("Negro");


Pixel p10 = new Pixel("Mixto");

Quadtree h1 = new Quadtree(p0);


. . .
Arboles Generales
. . . .
ArbolGeneral<Pixel> h9 = new ArbolGeneral<Pixel>(p8);

ArbolGeneral<Pixel> h10 = new ArbolGeneral<Pixel>(p9);
ListaGenerica<ArbolGeneral<Pixel>> hijosII = new ListaEnlazadaGenerica<ArbolGeneral<Pixel>>();

hijosII.agregarFinal(h1);
ArbolGeneral<Pixel> hizqizq = new ArbolGeneral<Pixel>(p10, hijosII);
ListaGenerica<ArbolGeneral<Pixel>> hijosCI = new ListaEnlazadaGenerica<ArbolGeneral<Pixel>>();

hijosCI.agregarFinal(h5);
ArbolGeneral<Pixel> hcentroizq = new ArbolGeneral<Pixel>(p11, hijosCI);
ListaGenerica<ArbolGeneral<Pixel>> hijos = new ListaEnlazadaGenerica<ArbolGeneral<Pixel>>();

hijos.agregarFinal(hizqizq);
hijos.agregarFinal(hcentroizq);
hijos.agregarFinal(h9);
hijos.agregarFinal(h10);
ArbolGeneral<Pixel> raiz = new ArbolGeneral<Pixel>(p12, hijos);
System.out.println("Los pixeles de color negro que posee la imagen es " + contar(raiz, 1024));
}
}
Arboles Generales
package parcial.quadtree;
public class CuentaPixels {
public static int contar(ArbolGeneral<Pixel> arbol, int cantidadTotal) {

int cantidad = 0;
if (arbol.esHoja() && arbol.getDato().esNegro()) {
return cantidadTotal;
} else if (!arbol.esHoja()) {
int cantidadHijos = cantidadTotal / 4;
for (int i = 1; i <= 4; i++) {
cantidad += contar(arbol.getHijos().elemento(i), cantidadHijos);
}
}
return cantidad;
}
. . . .

Algoritmos y Estructuras de Datos Algoritmos y Estructuras de Datos

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Algoritmos y Estructuras de Datos Algoritmos y Estructuras de Datos

Cargado por

Copyright:

Formatos disponibles

Algoritmos y Estructuras de Datos

Prof. Alejandra Schiavoni (ales@info.unlp.edu.ar)

Prof. Catalina Mostaccio (catty@lifia.info.unlp.edu.ar)

Prof. Laura Fava (lfava@info.unlp.edu.ar)

Prof. Pablo Iuliano (piuliano@info.unlp.edu.ar)

• Profundidad: de ni es la longitud del único camino desde la raíz

• Altura de ni es la longitud del camino más largo desde ni hasta

• La altura de un árbol es la altura del nodo raíz.

• Ancestro/Descendiente: si existe un camino desde n1 a n2, se

Altura(5) = 1 ¿Cuál es la altura del nodo 8?

Altura(5) = 1 ¿Cuál es la altura del nodo 8? 2

Es decir, recursivamente, T es lleno si :

• Cantidad de nodos en un árbol binario completo:

• Cantidad de nodos en un árbol binario completo:

• Cantidad de nodos en un árbol binario completo:

• Cantidad de nodos en un árbol binario completo:

• Cantidad de nodos en un árbol binario completo:

 Cada nodo tiene:

¿Por dónde empezamos?

¿Cómo armamos los subárboles? A

¿sub. izq.? ¿sub. der.?

¿Cómo están distribuidos los datos?

¿sub. izq.? ¿sub. der.?

¿Cómo están distribuidos los datos?

¿sub. izq.? ¿sub. der.?

sub. izq. sub. der.

¿sub. izq.? ¿sub. der.?

 Nodos internos representan operadores

 Nodos externos (hojas) representan operandos

 En compiladores para analizar, optimizar y traducir

a*( b*d +c) + ( e+ f*g )

Expresión prefija +*a+*b d c+ e *f g

tomo un carácter de la expresión

ArbolExpresión (A: ArbolBin, exp: string )

si exp nulo  nada.

Expresión infija 2+5*3+1

Expresión postfija 253*+1+

Expresión infija 2+5*3+1

Expresión postfija 253*+1+

(ii) Se usa la estrategia 1)

(i) Estrategia del Algoritmo para convertir exp. infija en postfija :

a) si es un operando  se coloca en la salida.

operador con > prioridad que el tope –> se apila

c) si es un “(“ , “)” “(“ se apila

d) cuando se llega al final de la expresión, se desapilan todos los elementos

Los “ ( “ siempre se apilan como si tuvieran la mayor

Algoritmos y Estructuras de Datos 2021 Prof: Laura Fava - Pablo Iuliano

public class ArbolGeneral<T> { public void agregarHijo(ArbolGeneral<T> unHijo) {

public ListaGenerica<ArbolGeneral<T>> getHijos() {

Algoritmos y Estructuras de Datos 2021 Prof: Laura Fava - Pablo Iuliano

Algoritmos y Estructuras de Datos 2021 Prof: Laura Fava - Pablo Iuliano

Algoritmos y Estructuras de Datos 2021 Prof: Laura Fava - Pablo Iuliano

public class ArbolGeneral<T> {

Algoritmos y Estructuras de Datos 2021 Prof: Laura Fava - Pablo Iuliano

Algoritmos y Estructuras de Datos 2021 Prof: Laura Fava - Pablo Iuliano

public class Personaje {

public Personaje(String nombre, String tipo) {

public boolean esDragon(){

Algoritmos y Estructuras de Datos 2021 Prof: Laura Fava - Pablo Iuliano

public ListaEnlazadaGenerica<Personaje> encontrarPrincesa(ArbolGeneral<Personaje> arbol){

Algoritmos y Estructuras de Datos 2021 Prof: Laura Fava - Pablo Iuliano

Algoritmos y Estructuras de Datos 2021 Prof: Laura Fava - Pablo Iuliano

Para esto, unaescriba

a( bd +c) + ( e+ f*g )

Expresión prefija +a+b d c+ e *f g