rboles Binarios

Un rbol binario es un rbol

tal que cada nodo tiene como
mximo dos subrboles.

Los rboles binarios suelen ser

utilizados como contenedores de
datos, por lo que ser importante
definir una funcin que compruebe
si un dato pertenece a un rbol.

data rbolB a = VacoB | NodoB

(rbolB a) a (rbolB a) deriving Show

 perteneceB :: Eq a => a -> rbolB a

-> Bool
perteneceB x VacoB = False
perteneceB x (NodoB i r d)
| x == r
= True
| otherwise
= perteneceB x i ||
perteneceB x d

rbol binario de bsqueda

En cualquier nodo los elementos del
subrbol izquierdo son menores y los
elementos del subrbol derecho son
mayores.
5
0

3
0
2
5

6
0

3
5

8
0

rbol binario de bsqueda en

Haskell
a2 :: rbolB Intu
a2 = NodoB (NodoB (hojaB 25)

30

(hojaB 35))

50

(NodoB VacoB

60

(hojaB 80))

where

hojaB x = NodoB VacoB x VacoB

Un rbol binario es de bsqueda?

todosrbolB :: (a -> Bool) -> rbolB a -> Bool
todosrbolB p VacoB
= True
todosrbolB p (NodoB i r d) = p r &&

todosrbolB p i && todosrbolB

pd
-------------------------------------------------------------- esrbolBB :: Ord a => rbolB a -> Bool
esrbolBB VacoB
= True
esrbolBB (NodoB i r d) = todosrbolB (< r) i &&

todosrbolB (>r) d &&

esrbolBB i &&

esrbolBB d

 Si el dato que buscamos no es la raz slo

hay que buscar en uno de los subrboles de
modo que como mximo se realizan tantas
comparaciones como profundidad tenga el
rbol.
Dado que es posible almacenar
datos en un rbol de profundidad n, el
algoritmo es de orden lg n.
La ganancia es significativa, frente a
utilizar una lista, ya que con esta estructura
puede ser necesario realizar n
comparaciones

Busca un elemento, en un rbol

binario de bsqueda
perteneceBB :: Ord a => a -> rbolB
a -> Bool
perteneceBB x VacoB = False
perteneceBB x (NodoB i r d)
| x == r = True
| x < r = perteneceBB x i
| otherwise = perteneceBB x d

Inserta un elemento, en un rbol

binario de bsqueda
insertarBB :: Ord a => a -> rbolB a
-> rbolB a
insertarBB x VacoB = NodoB VacoB
x VacoB
insertarBB x (NodoB i r d)
| x <= r = NodoB (insertarBB x i) r
d
| otherwise = NodoB i r (insertarBB x
d)

Eliminar un elemento en un
rbol binario de bsqueda
La eliminacin es ms complicada, ya que
si el nodo a eliminar tiene dos subrboles
no se puede dejar un hueco en su lugar.
Colocaremos el mayor elemento del
subrbol izquierdo del nodo a eliminar.
esVacoB :: rbolB a -> Bool
esVacoB VacoB = True
esVacoB _
= False

eliminarBB :: Ord a => a -> rbolB a ->

rbolB a
eliminarBB x VacoB = VacoB
eliminarBB x (NodoB i r d)
|x<r
= NodoB (eliminarBB x i) r d
|x>r
= NodoB i r (eliminarBB x d)
| esVacoB i = d
| esVacoB d = i
| otherwise = NodoB i' mi d
where
(mi, i') = tomaMaxBB i
tomaMaxBB (NodoB i r VacoB) = (r, i)
tomaMaxBB (NodoB i r d)
= (m,
NodoB i r d')
where
(m, d') = tomaMaxBB d

Recorrido en orden en un rbol

binario
El recorrido en orden de un rbol
binario dar como resultado una lista
con los datos de un rbol de modo
que primero se recorre el subrbol
izquierdo, luego la raz y por ltimo
el subrbol derecho.

Recorrido en orden, en
Haskell
enOrden :: rbolB a -> [a]
enOrden VacoB = []
enOrden (NodoB i r d) =
enOrden i ++ (r : enOrden d)