n15 Arbolesbinarios Arbolesbinariosordenados

1
NIVEL 15: ESTRUCTURAS RECURSIVAS

BINARIAS
Árboles Binarios y Árboles Binarios
Ordenados
ISIS1206 – Estructuras de Datos

http://cupi2.uniandes.edu.co
2
Contenido
• Árboles binarios
• Iteradores
• Árboles binarios ordenados

3
Árboles binarios
• Algunas definiciones para recordar:
- Subárbol - Padre - Hermano - Camino
- Árbol vacío - Hoja - Rama - Completo
- Hijo - Peso - Nivel - Lleno
- Altura -Recorrido en -Recorrido en -Recorrido en

inorden preorden postorden
-Recorrido por - Iterador -Estructura - Algoritmo recursivo

niveles recursiva

4
Ejercicio
• La raíz del árbol es:
• La altura del árbol es:
• El peso del árbol es:
• Hojas?
• Un elemento no terminal?.
• De quién es hijo 15?
• De quién es padre 25?
• Un ejemplo de hermanos.
• El camino entre 10 y 7:
• La longitud del camino entre 10 y 7 es:
• Nivel de 25:
• Es árbol completo? Es árbol lleno?.
• El recorrido en preorden es:
• El recirrido en postorden es :
• El recorrido en inorden es :
• El recorrido por niveles es :
5
Árboles binarios
• Formalismo Abstracto
e2
e4 e5
e1
r
e2 e3
e3
a1 a2 e4 e5 e6 e7
e6 e7
• Invariante
{inv: a1 y a2 son disyuntos}
6
Árboles binarios
• Cupi2 Collections tiene su

propia implementación del
árbol binario.
• Se utiliza genericidad
cupi2 collections

7
Implementación:

8
public class ArbolBinario<T> Se manejan elementos que

{ hereden de Comparable
private NodoArbolBinario<T extends Comparable<? super T>> raiz;
public int darPeso( )

{
return ( raiz != null ) ? raiz.darPeso( ) : 0;
}
}
public class NodoArbolBinario<T extends Comparable<? super T>>
{
private T elem;
private NodoArbolBinario<T> izqNodo; T es comparable con cualquiera
private NodoArbolBinario<T> derNodo; de sus supertipos
public int darPeso( )

{
int p1 = ( izqNodo == null ) ? 0 : izqNodo.darPeso( );
int p2 = ( derNodo == null ) ? 0 : derNodo.darPeso( );
return p1 + p2 + 1;
}
}
9
Árboles binarios
• Algorítmica básica:
• Es hoja?
• Altura
• Buscar un elemento

10
Árboles binarios
• Es hoja?
public class NodoArbolBinario<T>

{
private T elem;
private NodoArbolBinario<T> izqNodo;
private NodoArbolBinario<T> derNodo;
public boolean esHoja( )

{
return izqNodo == null && derNodo == null;
}
}

11
Árboles binarios
• Altura

12
public class ArbolBinario<T>

{
private NodoArbolBinario<T> raiz;
public int darAltura( )

{
return ( raiz != null ) ? raiz.darAltura( ) : 0;
}
}
{
private T elem;
private NodoArbolBinario<T> izqNodo;
private NodoArbolBinario<T> derNodo;
public int darAltura( )

{
int a1 = ( izqNodo == null ) ? 0 : izqNodo.darAltura( );
int a2 = ( derNodo == null ) ? 0 : derNodo.darAltura( );
return ( a1 >= a2 ) ? a1 + 1 : a2 + 1;
}
}
13
Árboles binarios
• Buscar un elemento

14
{
public T buscar( T modelo )

{
return ( raiz != null ) ? raiz.buscar( modelo ) : null;
}
}
{
{
if( modelo.equals( elem ) )
return elem;
else
{
T temp = ( izqNodo == null ) ? null : izqNodo.buscar( modelo );
if( temp != null )
return temp;
else
return ( derNodo == null ) ? null : derNodo.buscar( modelo );
}
}
}
15
Árboles binarios
• Buscar un elemento:
• Busca el elemento del árbol que corresponda al m

odelo
especificado.
• modelo: Descripción del elemento que se va a

buscar en el árbol. Debe contener por lo menos la
información mínima necesaria para que el método
de comparación del nodo pueda establecer una
relación de orden.
16
Iteradores (cupi2.collections)
public interface Iterador<T>

{
public boolean haySiguiente( );
public T darSiguiente( );
public void reiniciar( );
}

17
public class IteradorSimple<T> implements Iterador<T>

{
private final static int NADA = -1;
private T[] elems;
private int posActual;
private int sigPosLibre;
public boolean haySiguiente( );

public T darSiguiente( );
public void reiniciar( );
public IteradorSimple( int tamanio )

public void agregar( T elem ) throws IteradorException
public void insertar( T elem ) throws IteradorException
public int darSigPosLibre( )
public int darPosActual( )
public int darLongitud( )
}

18
Iteradores
• Para recorridos y retornos de secuencias en el árbol
binario.

{
public Iterador<T> darInorden( )
public Iterador<T> darPreorden( )
public Iterador<T> darCamino( T elem ) throws NoExisteException
public Iterador<T> darNivel( int nivel )
}

19
Árboles e iteradores
• Recorrido en inorden
{
public Iterador<T> darInorden( )
{
IteradorSimple<T> resultado = new IteradorSimple<T>( darPeso( ) );
if( raiz != null )
{
raiz.inorden( resultado );
}
return resultado;
}
}

20
Árboles e iteradores

21

{
public void inorden( IteradorSimple<T> resultado )
{
if( izqNodo != null )
{
izqNodo.inorden( resultado );
}
try
{
resultado.agregar( elem );
}
catch( IteradorException e )
{
}
if( derNodo != null )
{
derNodo.inorden( resultado );
}
}
}
22
Árboles binarios ordenados

• Formalismo abstracto
a1 a2
• Invariante
{ inv: a1 y a2 son disyuntos, todos los elementos de a1 son menores que e,
todos los elementos de a2 son mayores que e, a1 y a2 son ordenados}

23

• Implementación a dos niveles
public class ArbolBinarioOrdenado<T extends Comparable<? super T>>
{
private NodoArbolBinarioOrdenado<T> raiz;
private int peso;
}
public class NodoArbolBinarioOrdenado<T extends Comparable<? super T>>
{
private T elem;
private NodoArbolBinarioOrdenado<T> derNodo;
private NodoArbolBinarioOrdenado<T> izqNodo;
}

24

• Algorítmica básica
• Buscar
• Insertar
• Eliminar (4 variantes)

25

• Buscar

{
{
return ( raiz != null ) ? raiz.buscar( modelo ) : null;
}
}

26

• Buscar

27

{
{
// Compara el valor con el valor del nodo
int resultado = elem.compareTo( modelo );
if( resultado == 0 )
{
// Caso 1: El elemento buscado es el elemento actual
return elem;
}
else if( resultado > 0 )
{
// Caso 2: El elemento debería estar en el subárbol izquierdo
return ( izqNodo != null ) ? izqNodo.buscar( modelo ) : null;
}
else
{
// Caso 3: El elemento debería estar en el subárbol derecho
return ( derNodo != null ) ? derNodo.buscar( modelo ) : null;
}
}
}

28

• Insertar
{
public void insertar( T elemento ) throws ExisteException
{
if( raiz == null )
{
// Caso 1: el árbol es vacío
raiz = new NodoArbolBinarioOrdenado<T>( elemento );
}
else
{
// Caso 2: el árbol no es vacío
raiz.insertar( elemento );
}
peso++;
}
}
29
• Insertar
{
public void insertar( T pElemento ) throws ExisteException
{
int resultado = elem.compareTo( pElemento );
{
// Caso 1: El elemento a insertar es el elemento actual
throw new ExisteException( "Elemento presente en el árbol" );
}
{
// Caso 2: El elemento se debe insertar en el subárbol izquierdo
if( izqNodo == null )
izqNodo = new NodoArbolBinarioOrdenado<T>( pElemento );
else
izqNodo.insertar( pElemento );
}
else
{
// Caso 3: El elemento se debe insertar en el subárbol derecho
if( derNodo == null )
derNodo = new NodoArbolBinarioOrdenado<T>( pElemento );
else
derNodo.insertar( pElemento );
}
}
}

30

{
public void insertar( T pElemento ) throws ExisteException
{
{
// Caso 1: El elemento a insertar es el elemento actual
throw new ExisteException( "Elemento presente en el árbol" );
}
{
// Caso 2: El elemento se debe insertar en el subárbol izquierdo
izqNodo = new NodoArbolBinarioOrdenado<T>( pElemento );
else
izqNodo.insertar( pElemento );
}
else
{
// Caso 3: El elemento se debe insertar en el subárbol derecho
derNodo = new NodoArbolBinarioOrdenado<T>( pElemento );
else
derNodo.insertar( pElemento );
}
}
}

31

• Eliminar un elemento
• Variante 1: Para eliminar un elemento de la raíz,
se puede colocar el subárbol izquierdo a la
izquierda del menor elemento del subárbol
derecho:

32

• Ejemplo 30
20
25 35
10 30
10
5 15 25 35
5 15

33

• Variante 2: Para eliminar el elemento de la raíz, se
puede colocar el subárbol derecho a la derecha
del menor elemento del subárbol izquierdo.

34

10
• Ejemplo
20 5 15
10 30
30
5 15 25 35
25 35

35

• Variante 3: Para eliminar el elemento de la raíz, se
puede reemplazar dicho elemento por el menor
elemento del subárbol derecho

36

• Ejemplo
25
20
10 30 10 30
5 15 25 35 5 15 35

37

• Variante 4: Para eliminar un elemento de la raíz,
se puede reemplazar el elemento por el mayor
elemento del subárbol izquierdo.

38

• Ejemplo
15
20
10 30 10 30
5 15 25 35 5 25 35

39

• Bajo las variantes 3 y 4, se consideran 3
grandes casos:
• El elemento es la raíz.
• El elemento está en el subárbol izquierdo.
• El elemento está en el subárbol derecho.

40

• Si el elemento a eliminar es la raíz, se manejan
3 casos:
• Es una hoja (NO HAY PROBLEMA).
• Sólo tiene un hijo: se coloca al hijo.
• Están los dos subárboles: Busca el mayor
elemento del lado izquierdo, lo coloca en la raíz y
hace un llamado recursivo para suprimirlo.

41

• Eliminar
{
public void eliminar( T elemento ) throws NoExisteException

{
if( raiz != null )
{
// Caso 1: el árbol no es vacío
raiz = raiz.eliminar( elemento );
peso--;
}
else
{
// Caso 2: el árbol es vacío
throw new NoExisteException( "El elemento especificado no existe en el árbol" );
}
}
}

42

{
public NodoArbolBinarioOrdenado<T> eliminar( T pElemento ) throws NoExisteExcep

tion
{
{
// Caso 1: El elemento buscado es el elemento actual
return derNodo;
else if( derNodo == null )
return izqNodo;
else
{
elem = izqNodo.darMayor( );
izqNodo = izqNodo.eliminar( elem );
return this;
}
}
...

43

{

tion
{
...
{
// Caso 2: El elemento debe estar en el subárbol izquierdo
{
throw new NoExisteException( "El elemento no encontrado" );
}
else
{
izqNodo = izqNodo.eliminar( pElemento );
return this;
}
}
...

44

{

tion
{
...
else
{
// Caso 3: El elemento debe estar en el subárbol derecho
{
throw new NoExisteException( "El elemento no encontrado" );
}
else
{
derNodo = derNodo.eliminar( pElemento );
return this;
}
}
}

45

• Tarea:
• Leer árboles AVL.
• Estudiar árboles ordenados, árboles ordenados
binarios e iteradores de cupi2.collections.


n15 Arbolesbinarios Arbolesbinariosordenados

Cargado por

Copyright:

Formatos disponibles

n15 Arbolesbinarios Arbolesbinariosordenados

Cargado por

Información del documento

Descripción original:

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

n15 Arbolesbinarios Arbolesbinariosordenados

Cargado por

Copyright:

Formatos disponibles

1

NIVEL 15: ESTRUCTURAS RECURSIVAS

ISIS1206 – Estructuras de Datos

ISIS1206 – Estructuras de Datos

- Árbol vacío - Hoja - Rama - Completo

- Hijo - Peso - Nivel - Lleno

- Altura -Recorrido en -Recorrido en -Recorrido en

-Recorrido por - Iterador -Estructura - Algoritmo recursivo

ISIS1206 – Estructuras de Datos

• Cupi2 Collections tiene su

ISIS1206 – Estructuras de Datos

ISIS1206 – Estructuras de Datos

public class ArbolBinario<T> Se manejan elementos que

public int darPeso( )

public int darPeso( )

ISIS1206 – Estructuras de Datos

public class NodoArbolBinario<T>

public boolean esHoja( )

ISIS1206 – Estructuras de Datos

ISIS1206 – Estructuras de Datos

public class ArbolBinario<T>

public int darAltura( )

public int darAltura( )

ISIS1206 – Estructuras de Datos

public T buscar( T modelo )

• Busca el elemento del árbol que corresponda al m

• modelo: Descripción del elemento que se va a

public interface Iterador<T>

ISIS1206 – Estructuras de Datos

public class IteradorSimple<T> implements Iterador<T>

public boolean haySiguiente( );

public IteradorSimple( int tamanio )

ISIS1206 – Estructuras de Datos

public class ArbolBinario<T>

ISIS1206 – Estructuras de Datos

ISIS1206 – Estructuras de Datos

ISIS1206 – Estructuras de Datos

public class NodoArbolBinario<T>

Árboles binarios ordenados

ISIS1206 – Estructuras de Datos

Árboles binarios ordenados

ISIS1206 – Estructuras de Datos

Árboles binarios ordenados

ISIS1206 – Estructuras de Datos

Árboles binarios ordenados

public class ArbolBinarioOrdenado<T extends Comparable<? super T>>

ISIS1206 – Estructuras de Datos

Árboles binarios ordenados

ISIS1206 – Estructuras de Datos

public class NodoArbolBinarioOrdenado<T extends Comparable<? super T>>

ISIS1206 – Estructuras de Datos

Árboles binarios ordenados

ISIS1206 – Estructuras de Datos

public class NodoArbolBinarioOrdenado<T extends Comparable<? super T>>

ISIS1206 – Estructuras de Datos

Árboles binarios ordenados

ISIS1206 – Estructuras de Datos

Árboles binarios ordenados