ED Unidad 4: Estructuras de datos no lineales (árboles)

Estructuras de datos Carrera de Software
Ph.D. Franklin Parrales 1
09/03/2022
Estructuras de datos no
lineales (árboles)
Unidad 4
Material docente compilado por el profesor Ph.D. Franklin Parrales Bravo
para uso de los cursos de Estructuras de Datos

09/03/2022
Objetivo general de la Unidad 4
Implementar estructuras de datos no lineales mediante
objetos a través del uso de árboles binarios para el
almacenamiento de los datos en la memoria principal de
los programas.

09/03/2022
Contenido
• Teoría general de árboles binarios
– Conceptos generales
– Representación gráfica
– Estructura de árbol binario: Clase Árbol y constructor nodo del
árbol
– Clasificación y formas de recorrer árboles binarios: PreOrden,
InOrden,PostOrden
• Arbol binario de búsqueda (ABB)
– Operaciones en un ABB: Insertar, buscar, eliminar
• Arbol AVL
– Rotaciones de balanceo
– Operaciones en un AVL: Insertar, buscar, eliminar
• Ejercicios de aplicación

09/03/2022
Contenido
árbol
InOrden,PostOrden
• Arbol AVL

09/03/2022
Introducción
• Las listas enlazadas son estructuras lineales
– Son flexibles pero son secuenciales, un elemento detrás
de otro
• Los árboles
– Junto con los grafos son estructuras de datos no lineales
– Superan las desventajas de las listas
– Sus elementos se pueden recorrer de distintas formas, no
necesariamente uno detrás de otro
• Son muy útiles para la búsqueda y recuperación de
información

09/03/2022
Concepto
 Estructura que organiza sus elementos formando
jerarquías: PADRES E HIJOS
 Un subárbol de un árbol
 Es cualquier nodo del árbol junto con todos sus
descendientes
 Los elementos de un árbol se llaman nodos
 Si un nodo p tiene un enlace con un nodo m,
 p es el padre y m es el hijo
 Los hijos de un mismo padre se llaman: hermanos
A
B
D E
C
F
 Todos los nodos tienen al menos un padre, menos la raíz: A
 Si no tienen hijos se llaman hoja: D, E, F y C
B
D E F
A es Padre
B y C hijos de A:
hermanos
B es Padre
D, E, F hijos de B

09/03/2022
Terminología
• Nodo: los vértices o elementos de un árbol.
• Enlace/arco/arista: Conexión entre dos nodos consecutivos.
• Los nodos pueden ser:
– Nodo raíz: nodo superior de la jerarquía.
– Nodo terminal u hoja: nodo que no contienen ningún
subárbol.
– Nodos interiores: nodos con uno o más subárboles;
nodos que no son hojas.
– Descendientes o hijos: cada uno de los subárboles de
un nodo.
– Ascendiente, antecesor o padre: nodo de jerarquía
superior a uno dado.
– Nodos hermanos: nodos del mismo padre.
• Bosque: colección de árboles.

09/03/2022
Terminología
• Camino: Secuencia de nodos conectados dentro de un árbol
• Rama: camino que termina en una hoja.
• Longitud del camino: es el numero de nodos menos 1 en un
camino
• Altura del árbol: es el nivel mas alto del árbol
– Un árbol con un solo nodo tiene altura 1
• Nivel(profundidad) de un nodo: es el numero de nodos entre
el nodo y la raíz.
• Nivel de un árbol
– Es el numero de nodos entre la raíz y el nodo mas profundo del
árbol, la altura del un árbol entonces
• Grado(aridad) de un nodo: es numero de hijos del nodo
• Grado(aridad) de un árbol: máxima aridad de sus nodos
• Peso de un árbol: número de nodos terminales

09/03/2022
Terminología
Nivel 0
Nivel 1
Nivel 2
Nivel 3
Altura del árbol = 4
Peso del árbol = 6
A
B C
D E
H I
F G
J
K

09/03/2022
TDA Árbol: definición formal
<arbol> ::= <<NULL>> | <nodo>
<nodo> ::= <contenido>{<arbol>}
<contenido> ::= <<dato>>{<<dato>>}

09/03/2022
Arboles binarios (AB)
• Tipo especial de árbol
– Cada nodo no puede tener mas de dos hijos
• Un árbol puede ser un conjunto
– Vacío, no tiene ningún nodo
– O constar de tres partes:
• Un nodo raíz y
• Dos subárboles binarios: izquierdo y
derecho
• La definición de un árbol binario es
recursiva
– La definición global depende de si misma
A
B C
D
A
B C
D E
H I
F G
J
RAIZ
Sub. Izq. Sub. Der.

09/03/2022
Definiciones recursivas
• La definición del árbol es recursiva
– Se basa en si misma
• La terminología de los arboles
– También puede ser definida en forma
recursiva
• Ejemplo: NIVEL de un árbol
– Identificar el caso recursivo y el caso mas
básico
A
nivel 1
Caso Básico
Un arbol con un solo
nodo tiene nivel 1
Caso Recursivo
Si tiene mas de un nodo, el nivel es:
1 + MAX(Nivel(SubIzq), Nivel(SubDer))
S. izq.
Nivel 1
S. der.
Nivel 1
A
B C
Nivel Del Arbol: 2
SUB. IZQ.
Nivel = 1 +
Max(0,Sub.Izq)
SUB. DER.
Nivel 1
SUB. IZQ.
Nivel = 1 +
Max(0,Sub.Izq.)
SUB. DER..
Nivel = 1
SUB. IZQ.
Nivel = 1 +
Max(0,1)
A
B C
D
E
SUB. IZQ.
Nivel = 1 +
Max(0,2)
NIVEL : 1 + MAX(S.IZQ, S.DER)
NIVEL : 1 + MAX(3, 1)
NIVEL : 4
SUB. IZQ.
Nivel = 3

09/03/2022
Arboles binarios llenos
• Un árbol de altura h, esta lleno si
– Todas sus hojas esta en el nivel h
– Los nodos de altura menor a h tienen siempre 2
hijos
• Recursiva
– Si T esta vacío,
• Entonces T es un árbol binario lleno de altura 0
– Si no esta vacío, y tiene h>0
• Esta lleno si los subárboles de la raíz, son ambos arboles
binarios llenos de altura h-1

09/03/2022
Árboles binarios completos
• Un árbol de altura h esta
completo si
– Todos los nodos hasta el nivel h-2
tienen dos hijos cada uno y
– En el nivel h, si un nodo tiene un hijo
derecho, todas las hojas de su
subárbol izquierdo están a nivel h
• Si un árbol esta lleno, también
esta completo

09/03/2022
Otros
• Un árbol equilibrado es cuando
– La diferencia de altura entre los subárboles de
cualquier nodo es máximo 1
• Un árbol binario equilibrado totalmente
– Los subárboles izquierdo y derecho de cada nodo
tienen las misma altura: es un arbol lleno
• Un árbol completo es equilibrado
• Un árbol lleno es totalmente equilibrado

09/03/2022
AB y Nodo AB: Definición formal
<ab>::= nulo | <nodo>
<nodoab>::=<contenido>+<izq>+<der>
<izq>::=<ab>
<der>::=<ab>
<contenido>::<<dato>>|{<<dato>>}

09/03/2022
Contenido
árbol
InOrden,PostOrden
• Arbol AVL

09/03/2022
AB y Nodo AB: Declaración
• Un árbol binario: conjunto de nodos
– Solo se necesita conocer el nodo raiz
• Cada nodo
– Tiene Contenido y
– Dos enlaces: árbol hijo izquierdo, árbol hijo derecho
• Un nodo hoja, es aquel cuyos dos enlaces apunta a null
– Un nodo en un árbol tiene mas punteros a null que un nodo de una lista
• De un árbol solo se necesita conocer su raíz
– La raíz, que es un nodo, puede definir al árbol o
NodoArbol raiz;
NodoArbol izquierda;
NodoArbol derecha;

09/03/2022
AB y Nodo AB: Definición de las clases
• Clase Arbol • Clase NodoArbol
public class Arbol {
String nombre;
NodoArbol raiz;
public Arbol () {
nombre = null;
raiz = null;
}
}
public class NodoArbol {
int dato;
NodoArbol izquierda;
NodoArbol derecha;
public NodoArbol () {
dato = 0;
izquierda = null;
derecha = null;
}
}

09/03/2022
Clase NodoArbol más completa
class NodoArbol {
private int dato;
private NodoArbol izquierda, derecha;
public NodoArbol(int dato) {
this.dato = dato;
this.izquierda = this.derecha = null;
}
public int getDato() {
return dato;
}
public NodoArbol getIzquierda() {
return izquierda;
}
//continúa a la derecha…
public void setIzquierda(NodoArbol izquierda) {
this.izquierda = izquierda;
}
public NodoArbol getDerecha() {
return derecha;
}
public void setDerecha(NodoArbol derecha) {
this.derecha = derecha;
}
public void imprimirDato() {
System.out.println(this.getDato());
}
}

09/03/2022
Contenido
árbol
InOrden,PostOrden
• Arbol AVL

09/03/2022
Recorridos en árboles binarios
• En una estructura de datos lineal sólo es posible un tipo de
recorrido en dos sentidos distintos:
– Del primero al último o del último al primero.
• Una estructura de datos no lineal se puede recorrer de
distintas maneras:
– ¿Se realiza un recorrido por niveles, accediendo a los nodos
hermanos de cada nivel?
– Una vez situados en un nodo, ¿a qué hijo se accede primero?
– En que momento se accede a la información del nodo, ¿antes o
después de los hijos?
• En general existen dos grandes grupos de recorridos:
– Recorridos en anchura. Se accede a los nodos hermanos en
cada uno de los niveles del árbol
– Recorridos en profundidad. Se recorren las ramas de un
nodo dado.

09/03/2022
Recorre los vértices en orden
de su distancia desde el
origen
Visita a todos los vértices (el
ancho) de un nivel antes de
seguir con el siguiente
L M N O P
G
Q
H J
I K
F
E
D
B C
A
Recorrido en anchura

09/03/2022
Recorre todos los vértices de
una rama antes de seguir con
la siguiente
Visita a algunos vértices muy
lejanos (profundos) del origen
antes de otros cercanos
La implementación más fácil
pues es recursiva
L M N O P
G
Q
H J
I K
F
E
D
B C
A
Recorridos en profundidad

09/03/2022
Recorridos en profundidad
• Tres tipos de recorridos dependiendo del orden
en que se acceda al subárbol izquierdo, al
subárbol derecho o al nodo raíz
– En los tres recorridos se accede antes al hijo
izquierdo que al hijo derecho
– La variación reside en el momento en que se
recorrerá la información del nodo.
1. Recorrido preorden u orden previo (RID, raíz-hijo
izquierdo-hijo derecho)
2. Recorrido inorden u orden simétrico (IRD, hijo
izquierdo-raíz-hijo derecho)
3. Recorrido postorden u orden posterior (IDR, hijo
izquierdo- hijo derecho-raíz

09/03/2022
Recorrido InOrden: implementación
• Como ya revisamos, las operaciones de recorrido son
recursivas
• InOrden
– Recorrer InOrden al subárbol izquierdo
– Visitar nodo raíz
– Recorrer InOrden al subárbol derecho
• En todo algoritmo recursivo debemos buscar dos casos
– Básico, para terminar la recursividad
– Recursivo, donde la función se llama a si misma
Caso Básico
 Si AB_EstaVacio(raiz)
 Terminar de recorrer
Caso Recursivo
 Si !AB_EstaVacio(raiz)
 AB_InOrden (raiz->izq);
 Mostrar raiz->I
 AB_InOrden(raiz->der);
2

09/03/2022
Recorrido InOrden: implementación
• Preferido para:
– Recorrido de acuerdo al
orden físico de los nodos.
– En árboles binarios de
búsqueda recupera la
secuencia.
private void inorden(NodoArbol n) {
if (n != null) {
inorden(n.getIzquierda());
n.imprimirDato();
inorden(n.getDerecha());
}
}
A
B C
D E F G
Arbol Vacio!, Terminar
D
1
B
2
E
3
A
4
F
5
C
6
G
7
D-B-E-A-F-C-G

09/03/2022
Recorrido PreOrden: implementación
G
G-D
G-D-B
G-D-B-A
G-D-B-A-C
G-D-B-A-C-E
G
D K
B E H M
A C F J
I
L
G
1
D
2
B
3
A
4
C
5
E
6
F
7
G-D-B-A-C-E-F
K
8
G-D-B-A-C-E-F-K
H
9
G-D-B-A-C-E-F-K-H
J
10
G-D-B-A-C-E-F-K-H-J
I
11
G-D-B-A-C-E-F-K-H-J-I
M
12
G-D-B-A-C-E-F-K-H-J-I-M
L
13
G-D-B-A-C-E-F-K-H-J-I-M-L
1. Visitar raiz
2. Preorden al Subarbol Izq.
3. Preorden al Subarbol Der.
• Preferido para:
– Búsquedas
private void preorden(NodoArbol n) {
if (n != null) {
n.imprimirDato();
preorden(n.getIzquierda());
preorden(n.getDerecha());
}
}
1

09/03/2022
Recorrido PostOrden: implementación
• Preferido para:
– Liberar memoria.
– Nodos buscados en los niveles
más bajos del árbol.
3
+
-
*
D
C
*
B
A
H
A
A B
A B *
A B * C
A B * C D
A B * C D *
A B * C D * -
A B * C D * - H
A B * C D * - H +
private void postorden(NodoArbol n) {
if (n != null) {
postorden(n.getIzquierda());
postorden(n.getDerecha());
n.imprimirDato();
}
}

09/03/2022
Contenido
árbol
InOrden,PostOrden
• Arbol AVL

09/03/2022
Árbol binario de búsqueda (ABB)
• Los elementos en un árbol
– Hasta ahora no han guardado un orden
– No sirven para buscar elementos
• Los arboles de búsqueda (ABB)
– Permiten ejecutar en ellos búsqueda binaria
– Dado un nodo:
• Todos los nodos del sub. Izq. Tienen una clave
menor que la clave de la raiz
• Todos los nodos del sub. Der. Tienen una clave
mayor que la clave de la raiz
4
5
9
6
<>
30
41
75
55
4 85
<>

09/03/2022
Árboles binarios de búsqueda (ABB)
– Cada nodo tiene cero, uno o dos hijos, denominados
hijo izquierdo e hijo derecho.
– Los hijos de un nodo x con valores menores que x se
encuentran en el subárbol izquierdo y los mayores en el
derecho.
x
< x > x

09/03/2022
TDA ABB: Definición
• Valores:
– Conjunto de elementos
– Dado un nodo p,
• Los nodos del árbol izquierdo almacenan valores mayores al de p
• Los nodos del árbol derecho almacenan valores menores al de p
• Operaciones
– Son las mismas operaciones que para un AB
– Pero en este caso ya tenemos reglas suficientes que nos
indican como:
• Insertar
• Eliminar
• Buscar
<abb>::= NULL | <abb_nodo>
<abb_nodo>::=<clave>+<contenido>+<izq>+<der>
<izq>::=<abb>
<der>::=<abb>
<clave>::<<dato>>|{<<dato>>}
<contenido>::<<dato>>|{<<dato>>}

09/03/2022
• Son útiles para realizar búsqueda e inserción en
O(log n) y recorrido ordenado en O(n).
18
12 28
20 35
5
9

09/03/2022
• Inconveniente: En el peor caso los árboles son
cadenas y la búsqueda necesita O(n).
5
9
12
18
20
28
35

09/03/2022
ABB: Implementación (I)
public class ABB {
NodoArbol raiz;
public ABB () {
raiz = null;
}
/*Crea un nuevo nodo en el árbol, que queda apuntando a ese nodo*/
public void crearNodo () {
raiz = new NodoArbol ();
}
/*Devuelve la clave contenida en la raíz del árbol */
public int obtenerClave () {
int result = 0;
if (raiz != null)
result = raiz.dato;
return result;
}
/*Devuelve el hijo izquierdo del árbol*/
public NodoArbol devolverHijoIzquierdo () {
NodoArbol result = null;
if (raiz!= null)
result = raiz.izquierda;
return result;
}

09/03/2022
ABB: Implementación (II)
/*Devuelve el hijo derecho del árbol*/
public NodoArbol devolverHijoDerecho () {
NodoArbol result = null;
if (raiz != null)
result = raiz.derecha;
return result;
}
/*pone la clave pasada como argumento en la raíz del árbol*/
public void ponerClave (int clave) {
if (raiz != null)
raiz.dato = clave;
}
/*Hace que el árbol apunte al mismo sitio que nuevoArbol*/
public void ponerReferencia (NodoArbol nuevoArbol) {
raiz = nuevoArbol;
}
/*Hace que el hijo izquierdo del arbol apunte ahora a arbolAsignado*/
public void ponerHijoIzquierdo (NodoArbol arbolAsignado) {
if (raiz != null)
raiz.izquierda = arbolAsignado;
else
System.out.println ("Error, el árbol está vacío");
}

09/03/2022
ABB: Implementación (III)
/*Hace que el hijo derecho del arbol, apunte ahora a arbolAsignado*/
public void ponerHijoDerecho (NodoArbol arbolAsignado) {
if (raiz != null)
raiz.derecha = arbolAsignado;
else System.out.println ("Error, el árbol está vacío");
}
/*Hace que el arbol tome el valor null*/
public void asignarNulo () {
raiz = null;
}
/*Devuelve true si la raíz del arbol tiene valor null y false en caso contrario*/
public boolean esNulo () {
return raiz == null;
}
/*Devuelve true si la raíz del árbol y la de otroArbol apuntan al mismo sitio, false en caso
contrario*/
public boolean iguales (NodoArbol otroArbol) {
return (raiz == otroArbol);
}
/*Devuelve una referencia a la raiz del arbol*/
public NodoArbol devolverRaiz() {
return raiz;
}
}

09/03/2022
Contenido
árbol
InOrden,PostOrden
• Árbol binario de búsqueda (ABB)
• Árbol AVL

09/03/2022
Creación de un ABB
• Un árbol de búsqueda debe mantener
– A la derecha mayor a raíz
– A la izq. Menor a raíz
• Ejemplo:
– Construya árbol con los siguientes elementos:
• 8, 3, 1, 20, 10, 5, 4
8
3
1
20
10
5
4

09/03/2022
Búsqueda de un nodo
• Dada una clave, devolver el nodo que la contiene
• Se comienza en la raíz
– Si el árbol esta vacío
• No se encontró
– Si clave buscada es igual a la clave del nodo evaluado
• BINGO, LO ENCONTRE
– Si no
• Si la clave buscada es mayor a la del nodo evaluado
– Buscar en el subárbol derecho
• Si no
– Buscar en el subárbol izquierdo
8
3
1
20
10
5
4
Buscar(raiz,5)
5
5
Buscar(raiz,25)
No existe

09/03/2022
Búsqueda de un nodo
boolean encontrar (int dato) {
return encuentra (raiz,dato);
}
public static boolean encuentra (NodoArbol nodoArbol, int dato) {
boolean result = false;
if (nodoArbol != null)
if (nodoArbol.dato == dato)
result = true;
else if (nodoArbol.dato > dato)
result = encuentra (nodoArbol.izquierda, dato);
else
result = encuentra (nodoArbol.derecha, dato);
return result;
}

09/03/2022
Inserción de un nodo
• Muy parecido a la búsqueda
• Debo insertar en la posición correcta
– El árbol debe mantener sus propiedades
• Pasos:
– Crear una nueva hoja
– Buscar en el árbol donde ponerla
– Enlazar el nuevo nodo al árbol
8
3
1
20
10
5
4
Insertar(raiz,15)
15>8…der
15<20…izq
15>10
…der
Insertar
aqui
15

09/03/2022
Inserción de un nodo
static NodoArbol insertar (NodoArbol arbol, int dato) {
NodoArbol result = arbol;
if (arbol != null)
if (arbol.dato < dato)
arbol.derecha = insertar (arbol.derecha, dato);
else if (arbol.dato > dato)
arbol.izquierda = insertar (arbol.izquierda, dato);
else System.out.println ("la clave ya existe");
else result = new NodoArbol (dato);
return result;
}
public void insertar (int dato) {
raiz = insertar (raiz, dato);
}
Método de objeto
de Arbol
Método static que
recibe un NodoArbol
y devuelve otro
como resultado

09/03/2022
Eliminación de un nodo
• Es mas compleja que la inserción
• Al sacar un nodo del árbol
– El árbol debe mantener sus propiedades
– El árbol debe reajustarse
• Pasos:
– Buscar el nodo p que se va a eliminar
– Si el nodo a eliminar tiene menos de dos hijos
• Subir el nodo hijo a la pos. del nodo eliminado
– Si no
• Ubicar el nodo q con la mayor de las claves
menores
• Reemplazar contenido de p con el del nodo q
• Eliminar el nodo q que se encontró en el primer
paso
34
18
6
90
28
20
100
25
Eliminar(raiz,34)
34
nmayor
28
28

09/03/2022
static void eliminarClave (Arbol arbol, int dato) {
arbol.raiz = eliminarElemento (arbol.raiz, dato);
}
static NodoArbol eliminarElemento (NodoArbol arbol, int elem) {
NodoArbol p;
if (arbol != null)
if (arbol.dato > elem)
arbol.izquierda = eliminarElemento (arbol.izquierda, elem);
else if (arbol.dato < elem)
arbol.derecha = eliminarElemento (arbol.derecha, elem);
else {
p = arbol;
if (arbol.izquierda == null)
arbol= arbol.derecha;
else if (arbol.derecha == null)
arbol = arbol.izquierda;
else arbol.izquierda = eliminar2Hijos (arbol.izquierda, p);
}
else System.out.println (" la clave buscada no existe");
return arbol;
}

09/03/2022
static NodoArbol eliminar2Hijos (NodoArbol arbol, NodoArbol p) {
NodoArbol result;
if (arbol.derecha != null) {
result = arbol;
arbol.derecha = eliminar2Hijos (arbol.derecha, p);
}
else {
p.dato = arbol.dato;
result = arbol.izquierda;
}
return result;
}

09/03/2022
Contenido
árbol
InOrden,PostOrden
• Árbol AVL

09/03/2022
Eficiencia de los ABB
• Los ABB se utilizan
– Para almacenar datos en forma ordenada
– Y facilitar la búsqueda de información
• La estructura de un ABB
– Depende del orden en que se añaden sus nodos
– Si todos los elementos se añaden en orden creciente:
– El árbol queda alineado todo hacia la derecha
• Y la búsqueda ya no es binaria(2 posibilidades),
es lineal(1)
Ejemplo:
12, 18, 27 y 35
12
18
27
35

09/03/2022
Más eficiencia
• El árbol debe guardar otra estructura
• Algo mas equilibrado,
– Asegurar siempre una búsqueda binaria
– Que a partir de un nodo N con clave K
• Aprox. la mitad tengan claves mayores que K
• Y aprox. la otra mitad tengan claves menores
• Si se asegura equilibrio, se asegura
eficiencia
12
35
18
27
12
18
27
35
ABB Ineficiente,
Busqueda lineal
ABB Eficiente, la busqueda
siempre es binaria

09/03/2022
Arboles balanceados o equilibrados (AVL)
(Adelson-Velskii y Landis)
• Es un Árbol Binario especial, en donde
– Para c/Nodo p del árbol
• La Altura(p->izq) y Altura(p->der) nunca difieren entre si en
mas de una unidad
5
8
10
6
4
5
8
10
7
4
6
0
0
0
1
Altura
=
1
Altura
=
2
Altura
=
1
Altura
=
1
Alt(izq) –
Alt(der)= 0
0
0
-1
-1
2
0
Factor de Equilibrio
= Alt(Der) – Alt(Izq)
En equilibrio,
F.E. Debe ser
–1, 0 o 1
ARBOL NO EQUILIBRADO
0
private static final int HEIGHT_DIFFERENCE=1

09/03/2022
TDA AVL: Implementación
public class AVLTree<T extends Comparable<? super T>> {
private AVLNode<T> root;
//La diferencia de altura entre los elementos
secundarios izquierdo y derecho del nodo no puede exceder
este valor
private static final int HEIGHT_DIFFERENCE=1;
public AVLTree(AVLNode<T> root) {
this.root = root;
}
}
class AVLNode<T>{
T data;
AVLNode<T> left;
AVLNode<T> right;
int height;
AVLNode(T t){
this(t,null,null);
}
AVLNode(T data,AVLNode<T> lt,AVLNode<T> rt){
this.data=data;
left=lt;
right=rt;
this.height=0;
}
}

09/03/2022
Arboles de Fibonacci
• Es un árbol equilibrado especial
• Definición
– Un árbol vacío es un AF de altura 0, AF(0)
– Un árbol con 1 nodo es un AF (1)
– Un AF(h) se define
• AF(h) = <AF(h-1), x, AF(h-2)>
– Si hablamos en términos de Nodos
• Cuando h es 0, TotalNodos(0) = 0
• Cuando h es 1, ToalNodos(1) = 1
• Para toda h >= 2: TotalNodos(h) = TotalNodos(h-1) + 1 +
TotalNodos(h-2)
AF(3)
TotalNodos(3) = 4
No es un Arbol de
Fibonacci

09/03/2022
Contenido
árbol
InOrden,PostOrden
• Árbol AVL

09/03/2022
Reestructuración
• Un AVL debe conservar su equilibrio
– En todo momento
• Al añadir o eliminar un nodo
– La altura del árbol puede cambiar
– Los factores de equilibrio deberán
recalcularse
• Si al recalcular, encontramos que un F.E.
no es ni –1 ni 0 ni 1
– Hay que reestructurar el árbol: ROTARLO

09/03/2022
Inserción: casos posibles
• Al insertar una nueva clave
– Pueden darse algunos casos, que dependerán de las alturas de
los subárboles (izq y der)
• Tipos de Casos
– Altura no es afectada, todo OK
– Altura es afectada y algún F.E. se daña, hay que decidir que
tipo de reestructuración es:
1. Rotación simple, rotación derecha (II)
2. Doble rotación, primero a la izquierda, luego a la derecha (ID)
3. Doble rotación, derecha e izquierda (DI)
4. Rotación simple, rotación izquierda (DD)

09/03/2022
CASO: TODO OK
• Cuando la altura no cambia o
• Aunque la altura cambie, la diferencia de alturas sigue OK
• Ejemplo
0
0
-1
0 0
1
 El arbol se equilibra completamente
0
0
•Si se inserta por izq, FE
de la raiz disminuye
•Si se inserta por der, FE
de la raiz aumenta
0
0
0
0
0
-1
-1
0
0
0
1
0
1
 La altura cambia pero los factores se
mantienen en -1,0,1

09/03/2022
Rotación simple, rotación derecha
B
A

 
B
A
 

1

09/03/2022
 El peso del arbol cae mas para la izq. y hay desbalanceo
 Si se detecta un F.E. -2, el daño
viene por la izquierda
 Si el siguiente nodo también
tiene un F.E. negativo(-1), hay
que rotar a la derecha
18
12
0
-1
9
0
-1
-2
ALERTA, F.E. FUERA DE
RANGO !!!
0
12
9 18
0
0
Al rotar
n
n1
Los F.E. de
n y n1,
quedaron 0

09/03/2022
• Parece que un nodo me “impidiese” rotar
25
0
9
0
17
0
18
-1
12
0
1
0
-1
-1
-2
tiene un F.E. negativo(-1), hay
que rotar a la derecha
n
n1
Al rotar, el 18
debe bajar, no
importa el 17
18
0
1
0
25
0
12
0
9
-1
¿y el
17?
17
0
Los F.E. de
n y n1,
quedaron 0

09/03/2022
Implementación
(Rotación simple, rotación derecha)
/**
* Rotación simple (rotación derecha) (caso 1)
* @param node
* @return
*/
private AVLNode<T>rotateRight(AVLNode<T> node){
AVLNode<T> left=node.left;
node.left=left.right;
left.right=node;
node.height=Math.max(height(node.left),height(node.right))+1;
left.height=Math.max(height(node.left),node.height)+1;
return left;
}
Gire a la derecha para que su hijo izquierdo se quede primero
1. El hijo izquierdo del nodo se convierte en el hijo derecho del izquierdo
2. El hijo derecho de la izquierda se convierte en nodo
3. Vuelva a calcular la altura del nodo y la izquierda

09/03/2022
Rotación simple, rotación izquierda
A
B

 
A
B
 

4

09/03/2022
• Similar a la rotacion II, pero el mayor peso cae sobre el
arbol derecho
 Si se detecta un F.E. 2, el daño
viene por la derecha(positivo)
tiene un F.E. 1 , hay que rotar a
la izquierda
ALERTA, F.E. FUERA DE
RANGO !!!
30
25
18
0 0
0
Al rotar
Los F.E. de
n y n1,
quedaron 0
18
1
25
0
30
0
1
2
n
n1

09/03/2022
Parece que un nodo me “impidiese” rotar
G

09/03/2022
Implementación
(Rotación simple, rotación izquierda)
/**
* Rotación simple (rotación izquierda) (caso 4)
* @param node
* @return
*/
private AVLNode<T> rotateLeft(AVLNode<T> node){
AVLNode<T> right=node.right;
node.right=right.left;
right.left=node;
node.height=Math.max(height(node.left),height(node.right))+1;
right.height=Math.max(node.height,height(right.right))+1;
return right;
}
Gire a la izquierda para obtener su hijo derecho primero
1. El hijo derecho del nodo se convierte en el hijo izquierdo del derecho
2. El hijo izquierdo derecho se convierte en nodo
3. Vuelva a calcular la altura del nodo y la derecha

09/03/2022
Doble rotación, primero a la izquierda,
luego a la derecha
2

 
B
A
C
C
B A

   

09/03/2022
luego a la derecha
• El peso del arbol cae mas a la izquierda, pero….
17
0
18
-1
12
0
1
-2
 Si el siguiente nodo tiene un F.E.
positivo, hay que rotar ID
n
n1
AL ROTAR
18
0
17
0
12
0
n2
Los F.E. de
n y n1,
quedaron 0

09/03/2022
luego a la derecha
• Cuando existen nodos que “estorban” en la rotación
25
0
9
0
17
0
18
-1
12
0
25
0
9
0
16
0
18
-1
12
0
17
0
15
0
-1
1
-2
Un F.E. -2,
ROTAR I
n
F.E. 1
ROTAR
ID
n1
n2
1
1
-2
n
n1
n2
18
1
9
0
15
0
17
0
12
0 25
0
Si el F.E. de
n2 es -1, al
rotar:
n->fe = 1,
n1->fe =
n2->fe = 0
18
0
9
0
16
0
12
-1 25
0
17
0
Si el F.E. de
n2 es 1, al
rotar :
n1->fe= -1
n->fe =
n2->fe = 0

09/03/2022
Implementación
(Doble rotación, primero a la izquierda, luego a la derecha)
/**
* Doble rotación (primero a la izquierda y luego a la derecha) (para el escenario 2)
* @param node
* @return
*/
private AVLNode<T> doubleLeftAndRight(AVLNode<T> node){
node.left=rotateLeft(node.left);
return rotateRight(node);
}
Con base en el Caso II y el Caso DD, es muy simple implementar
el Caso ID nuevamente:
1. Primero gire el hijo izquierdo de A
2. Gire A de nuevo a la derecha

09/03/2022
Doble rotación, derecha e izquierda
3

 
A
B
C
C
A B

   

09/03/2022
• El peso del arbol cae mas a la derecha, pero….
18
1
25
0
20
0
-1
2
n
n2
n1
 Si se detecta un F.E. 2, el daño
viene por la derecha
 Si el siguiente nodo tiene un F.E.
negativo, hay que rotar DI
18
20
0
0
25
0
AL ROTAR

09/03/2022
D

09/03/2022

09/03/2022
Implementación
(Doble rotación, derecha e izquierda)
/**
* Doble rotación (primero a la derecha y luego a la izquierda) (para el escenario 3)
* @param node
* @return
*/
private AVLNode<T> doubleRightAndLeft(AVLNode<T> node){
node.right=rotateRight(node.right);
return rotateLeft(node);
}
Con base en el Caso II y el Caso DD, es muy simple implementar
el Caso ID nuevamente:
1. Primero gire el hijo derecho de A
2. Gire A de nuevo a la izquierda

09/03/2022
Ejercicio
• Crear un AVL insertando las siguientes
claves: 68-45-29-75-90-70-34
68
0
45
0
-1
29
0
-1
-2
Rotar der.
45
0
68
0
29
0
75
0
1
1
90
0
1
2
2
Rotar izq.
90
0
45
1
68
0
75
0
29
0
70
0
1
-1
2
Rotar DI
90
0
68
0
70
0
75
0
45
-1
29
0
34
0
1
-2
-1
Rotar ID
90
0
68
0
70
0
75
0
34
0
29
0
45
0

09/03/2022
Contenido
árbol
InOrden,PostOrden
• Árbol AVL

09/03/2022
Operaciones sobre un AVL
• La búsqueda en un AVL es exactamente igual que
sobre un ABB.
• La inserción y eliminación son también como en
un ABB, pero después de insertar o eliminar hay
que comprobar la condición de balanceo.
– Almacenar la altura de cada subárbol.
– Inserción o eliminación normal (procedimiento recursivo).
– Al volver de la recursividad, en los nodos por los que
pasa, comprobar la condición de balanceo.
– Si no se cumple, rebalancear el árbol.

09/03/2022
Insertar un nodo (1)
public void insert(T data){
if (data==null){
throw new IllegalArgumentException("Los datos están vacíos");
}
root= insert(data, this.root);
}
private AVLNode<T> insert(T data, AVLNode<T> t){
if (t==null){
return new AVLNode<>(data,null,null);
}
int compareResult=data.compareTo(t.data);
if (compareResult<0){
t.left=insert(data,t.left);
}else if (compareResult>0){
t.right=insert(data,t.right);
}else {
System.out.println ("la clave ya existe");
}
return balance(t);
}

09/03/2022
Insertar un nodo (2)
• Se puede ver que, a excepción de la última
línea, el resto es el mismo que el árbol de
búsqueda binario.
• Después de cada llamada insert(), el
nodo actual debe ser reequilibrado, es decir,
cuando se encuentra el nodo insertado, la
pila de llamadas recursivas se utiliza para
realizar el reequilibrio en cada nodo en la
ruta.
• Reequilibrio balance()
– El código de equilibrio del nodo es el siguiente:

09/03/2022
Balance
private AVLNode<T> balance(AVLNode<T> t) {
if (t==null){
return null;
}
if (height(t.left)-height(t.right)>HEIGHT_DIFFERENCE){
// arriba a la izquierda
if (height(t.left.left)>=height(t.left.right)){
// La altura del subárbol izquierdo del subárbol izquierdo
// Este es el caso 1, inserte un elemento en el subárbol izquierdo del subárbol izquierdo y gírelo
directamente
t=rotateRight(t);
}else {
// La altura del subárbol derecho del subárbol izquierdo
// Este es el caso 2, un elemento se inserta en el subárbol derecho del subárbol izquierdo, primero
gira a la izquierda y luego a la derecha
t=doubleLeftAndRight(t);
}
}else if (height(t.right)-height(t.left)>HEIGHT_DIFFERENCE){
// Alta derecha
if (height(t.right.left)>height(t.right.right)){
// El subárbol izquierdo del subárbol derecho es más alto
// Este es el caso 3, un elemento se inserta en el subárbol izquierdo del subárbol derecho, primero
gira a la derecha y luego a la izquierda
t=doubleRightAndLeft(t);
}else {
// La altura del subárbol derecho del subárbol derecho
// Este es el caso 4, se inserta un elemento en el subárbol derecho del subárbol derecho y se gira
directamente hacia la izquierda
t=rotateLeft(t);
}
}
// Recalcula la altura del nodo
t.height=Math.max(height(t.left),height(t.right))+1;
return t;
private int height(AVLNode<T> t){
return t==null?-1:t.height;
}

09/03/2022
Eliminar un nodo
La lógica es la
misma que en el
ABB, y al igual
que en la
inserción, el nodo
actual debe
equilibrarse
después de cada
llamada de
eliminación.
public void remove( T x ) {
root = remove( x, root );
}
private AVLNode<T> remove(T data, AVLNode<T> root){
if (root==null){
return null;
}
int compareResult=data.compareTo(root.data);
if (compareResult<0){
root.left=remove(data,root.left);
}else if (compareResult>0){
root.right=remove(data,root.right);
}else if (root.left!=null&&root.right!=null){
// El nodo a eliminar tiene dos hijos
AVLNode<T> mayorDeMenores=findMax(root.left);
remove(mayorDeMenores.data);
root.data=mayorDeMenores.data;
}else {
// El nodo a eliminar no tiene o tiene un hijo
root=root.left==null?root.right:root.left;
}
// reequilibrar el árbol
return balance(root);
}

09/03/2022
Búsqueda de un nodo… igual que ABB
public boolean contains(T t) {
return find(root, t);
}
private boolean find(AVLNode<T> root, T t) {
boolean result=false;
if (root!= null){
int compareResult=t.compareTo(root.data);
if (compareResult==0)
result=true;
else if (compareResult>0)
result=find(root.left,t);
else
result=find(root.right,t);
}
return result;
}
La lógica es la
misma que en
el ABB

09/03/2022
findMax y findMin
public AVLNode<T> findMin(AVLNode<T> n) {
if(n==null)
return null;
else if(n.left==null)
return n;
return findMin(n.left);
}
public AVLNode<T> findMax(AVLNode<T> n) {
if(n==null)
return null;
else if(n.right==null)
return n;
return findMax(n.right);
}
18
1 25
12
9
17
<>

09/03/2022
Recorrido InOrden mediante cola de datos
Podemos recorrer InOrden el árbol AVL mediante una cola:
public Queue<T>iterator(){
if (isEmpty()){
return null;
}else {
Queue<T>queue=new LinkedList<>();
return iterator(root,queue);
}
}
private Queue<T> iterator(AVLNode<T> t, Queue<T> queue) {
if( t != null ) {
iterator( t.left,queue );
queue.add(t.data);
iterator( t.right,queue);
}
return queue;
}

09/03/2022
Prueba
public static void main(String[] args) {
AVLTree<Integer> avlTree = new AVLTree<>(new AVLNode<>(1));
avlTree.insert(2);
avlTree.insert(3);
avlTree.insert(4);
avlTree.insert(5);
avlTree.insert(6);
avlTree.insert(7);
avlTree.insert(15);
avlTree.insert(16);
avlTree.insert(14);
// Impresión transversal InOrden
avlTree.printTree();
System.out.println("========== Eliminar nodo 15 =========");
avlTree.remove(15);
Queue<Integer> queue = avlTree.iterator();
while (!queue.isEmpty()){
System.out.println(queue.dequeue());
}
Integer max = avlTree.findMax();
System.out.println("Elemento máximo:"+max);
System.out.println("¿Existe el nodo 17"+avlTree.contains(17));
}

09/03/2022
Resultado
1
2
3
4
5
6
7
14
15
16
==========Eliminar nodo15=========
1
2
3
4
5
6
7
14
16
Elemento más grande:16
nodo17existefalse

09/03/2022
Para resumir:
• La implementación general del árbol AVL es la
misma que el árbol de búsqueda binaria,
excepto que…
– para restablecer el equilibrio del árbol, el nodo actual
necesita ser balanceado en la llamada recursiva.
• Búsqueda de árbol AVL, inserción o eliminación,
la peor complejidad es O(log (n))

09/03/2022
Contenido
árbol
InOrden,PostOrden
• Árbol AVL

09/03/2022
Aplicación: evaluación de expresiones
• Ya sabemos lo de las expresiones, cierto?
– InFija, operador en medio
– PreFija, operador antes de dos operandos
– PosFija, operador luego de dos operandos
• Para evaluar una expresión dada, podríamos
– Pasarla a posfija y usar solo pilas
– Pasarla a posfija y usar pilas y un árbol de expresión

09/03/2022
Árbol de expresión
• Arboles que representan expresiones en
memoria
– Todos los operadores tienen dos operandos
• La raíz puede contener el operador
• Hijo izq: operando 1, Hijo derecho: operando 2
– Ejemplo: (a+b)
+
a b
(a+b)*c
+
a b
c
*

09/03/2022
Ejercicio en clase
• Construya arboles de expresion para:
– [X+(Y*Z)] * (A-B)
• Deducir las expresiones de los siguientes A.B.
+
a *
b -
+
c d

09/03/2022
Evaluar una expresión aritmética en InOrden
• La expresion se transforma a la expresion
posfija
– Esto, ya sabemos como hacer
• Crear un arbol de expresion
– Para esto se va a usar una pila y un arbol de
caracteres
• Usando el arbol, evaluar la expresion

09/03/2022
Crear un árbol de expresión
• Los operandos serán siempre nodos hoja del árbol
– Al revisar un operando, creo una nueva hoja y la recuerdo
• Los operadores serán nodos padre
– Al revisar un operador, recuerdo las dos ultimas hojas creadas y
uno todo
– No debo olvidar el nuevo arbolito que he creado
A*B-C*D+H AB*CD*-H+
A
B *
B
A
C
D
*
D
C
-
*
D
C
*
B
A
H
+
-
*
D
C
*
B
A
H

09/03/2022
Evaluación de la exp. Postfija
• Lo ideal es recuperar los dos operandos, el operador, y ejecutar la opcion
• Que recorrido es el ideal?
– PostOrden
+
-
*
D
C
*
B
A
H
Para evaluar el arbol:
Si el arbol tiene un solo nodo y este almacena un
operando
El resultado de la evaluacion es el valor de ese
operando
Si no
1. Res1 = Evaluo subarbol izquierdo
2. Res2 = Evaluo subarbol derecho
3. Recupero la info de la raiz y efectuo la
operación alli indicada, entre Res1 y Res2
A
A y B
A * B
(A * B) y C
(A * B) y C y D
(A * B) y (C*D)
(A * B) - (C*D)
(A * B) - (C*D) y H
(A * B) - (C*D) + H

09/03/2022
Árboles B
• Los árboles B son muy usados en Bases de Datos.
• Necesidades propias de las aplicaciones de BD:
– Muchos datos, básicamente conjuntos y diccionarios.
– El acceso secuencial y directo deben ser rápidos.
– Datos almacenados en memoria secundaria (disco) en
bloques.
• Existen muchas variantes: árboles B, B+ y B*.
• Idea: Generalizar el concepto de árbol binario de
búsqueda a árboles de búsqueda n-arios.

09/03/2022
Árboles B
Árbol Binario
de Búsqueda
Árbol de Búsqueda N-ario
• En cada nodo hay n claves y n+1 punteros a nodos hijos.
x
< x > x
< a
> a
< b
> b
< c
> c
a b c

09/03/2022
Árboles B
• Definición: Un árbol B de orden p es un árbol n-
ario de búsqueda, que cumple las siguientes
propiedades:
– Raíz del árbol: o bien no tiene hijos o tiene como mínimo
tiene 2 y como máximo p.
– Nodos internos: tienen entre p/2 y p hijos.
– Nodos hoja: todas las hojas deben aparecer al mismo
nivel en el árbol (condición de balanceo).
• Idea intuitiva: Cada nodo tiene p posiciones (p
punteros y p-1 claves) que deben “llenarse” como
mínimo hasta la mitad de su capacidad.

09/03/2022
Árboles B
• Búsqueda: igual que en los árboles binarios,
eligiendo la rama por la que seguir.
• La altura del árbol es ~ logp/2 n, en el peor caso.
63 73
20 30
22 25 29
4 13 15 16 33 34
45 62
41 42 47 52
39
Árbol B de
orden p=5

09/03/2022
Árboles B
• Inserción de entradas en un árbol B: Buscar el
nodo hoja donde se debería colocar la entrada.
– Si quedan sitios libres en esa hoja, insertarlo (en el
orden adecuado).
– Si no quedan sitios (la hoja tiene p-1 valores) partir la
hoja en 2 hojas (con (p-1)/2 y (p-1)/2 nodos cada
una) y añadir la mediana al nodo padre.
• Si en el padre no caben más elementos, repetir
recursivamente la partición de las hojas.
20 27 42 68
33
20 33 42 68
27

09/03/2022
Árboles B
• Ejemplo: En un árbol B de orden p=4, insertar las
claves: 37, 14, 60, 9, 22, 51, 10, 5, 55, 70, 1, 25.
• ¿Cuál es el resultado en un árbol B de orden p=5?
9 14
51 55
10 22 25 70
60
1 5
37

09/03/2022
Árboles B
• Eliminación de entradas en un árbol B: Buscar
la clave en el árbol.
– Nodo interno (no hoja): Sustituirla por la siguiente
(o la anterior) en el orden. Es decir, por la mayor de
la rama izquierda, o la menor de la rama derecha.
– Nodo hoja: Eliminar la entrada de la hoja.
• Casos de eliminación en nodo hoja. d = (p-1)/2
– Nodo con más de d entradas: suprimir la entrada.
– Nodo con d entradas (el mínimo posible):
reequilibrar el árbol.

09/03/2022
Árboles B
• Eliminación en nodo con d entradas:
– Nodo hermano con más de d entradas: Se
produce un proceso de préstamo de entradas:
Se suprime la entrada, la entrada del padre pasa a
la hoja de supresión y la vecina cede una entrada
al nodo padre.
20 30 45 62
39
35 67
70
73 82
Árbol B, p=5
d= 2
• Ejemplo. Eliminar 67, 45.

09/03/2022
Árboles B
• Eliminación en nodo con d entradas:
– Nodo hermano con más de d entradas: Se
produce un proceso de préstamo de entradas:
Se suprime la entrada, la entrada del padre pasa a
la hoja de supresión y la vecina cede una entrada
al nodo padre.
20 30 39 62
35 70
73 82
Árbol B, p=5
d= 2
• Ejemplo. Eliminar 67, 45.

09/03/2022
Árboles B
– Ningún hermano con más de d entradas: Con la
hoja donde se hace la supresión (d-1 entradas) más
una hoja hermana (d entradas) más la entrada del
padre, se crea una nueva hoja con 2d entradas.
20 30 39 62
35 70
73 82
Árbol B, p=5
d= 2
• Ejemplo. Eliminar 39.

09/03/2022
Árboles B
– Ningún hermano con más de d entradas: Con la
hoja donde se hace la supresión (d-1 entradas) más
una hoja hermana (d entradas) más la entrada del
padre, se crea una nueva hoja con 2d entradas.
20 30 62 70
35
73 82
Árbol B, p=5
d= 2
• Ejemplo. Eliminar 39.
• Ojo: Se suprime una entrada en el padre. Se debe
repetir el proceso de eliminación en el nivel superior.

09/03/2022
Árboles B
Conclusiones
• El orden de complejidad es proporcional a la altura
del árbol, ~ logp/2 n en el peor caso.
• Normalmente, el orden p del árbol se ajusta para
hacer que cada nodo esté en un bloque de disco,
minimizando el número de operaciones de E/S.
• Representación en memoria: mejor usar AVL.
• Representación en disco: mejor usar árboles B.

09/03/2022
Estructuras de datos no
lineales (árboles)
Unidad 4
Final de la unidad
Y del curso…. !Muchas gracias
a todos!

ED Unidad 4: Estructuras de datos no lineales (árboles)

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a ED Unidad 4: Estructuras de datos no lineales (árboles)

Similar a ED Unidad 4: Estructuras de datos no lineales (árboles) (20)

Más de Franklin Parrales Bravo

Más de Franklin Parrales Bravo (20)

Último

Último (6)

ED Unidad 4: Estructuras de datos no lineales (árboles)