arboles binarios y generales
Post on 29-Nov-2014
463 Views
Preview:
TRANSCRIPT
Arboles binarios y generales
Clara Segura y Alberto Verdejo
Dpto. de Sistemas Informaticos y Programacion
Universidad Complutense de Madrid
Marzo 2005
Arboles binarios: Especificacion
especificacion ARBOLES-BINARIOS[ELEM]usa BOOLEANOStipos arbol-binoperaciones
arbol-vacıo : −→ arbol-bin { constructora }plantar : arbol-bin elemento arbol-bin −→ arbol-bin { constructora }raız : arbol-bin −→p elementohijo-iz : arbol-bin −→p arbol-binhijo-dr : arbol-bin −→p arbol-bines-arbol-vacıo? : arbol-bin −→ bool
2
variables
e : elementoiz , dr : arbol-bin
ecuaciones
hijo-iz(arbol-vacıo) = errorhijo-iz(plantar(iz , e, dr )) = iz
hijo-dr(arbol-vacıo) = errorhijo-dr(plantar(iz , e, dr )) = dr
raız(arbol-vacıo) = errorraız(plantar(iz , e, dr )) = e
es-arbol-vacıo?(arbol-vacıo) = ciertoes-arbol-vacıo?(plantar(iz , e, dr )) = falso
fespecificacion
3
Arboles binarios: Implementacion
tiposenlace-arbol = puntero a nodo-arbolnodo-arbol = reg
valor : elementoiz , dr : enlace-arbol
freg
arbol-bin = enlace-arbolftipos
fun arbol-vacıo() dev a : arbol-bin { Θ(1) }a := nil
ffun
fun plantar(iz : arbol-bin, e : elemento, dr : arbol-bin) dev a : arbol-bin { Θ(1) }reservar(a)a↑ .valor := e
a↑ .iz := iz
a↑ .dr := dr
ffun
4
fun hijo-iz(a : arbol-bin) dev b : arbol-bin { Θ(1) }si a = nil entonces error(Arbol vacıo)si no b := a↑ .iz
fsi
ffun
fun hijo-dr(a : arbol-bin) dev b : arbol-bin { Θ(1) }si a = nil entonces error(Arbol vacıo)si no b := a↑ .dr
fsi
ffun
fun raız(a : arbol-bin) dev e : elemento { Θ(1) }si a = nil entonces error(Arbol vacıo)si no e := a↑ .valor
fsi
ffun
fun es-arbol-vacıo?(a : arbol-bin) dev b : bool { Θ(1) }b := (a = nil)
ffun
5
Recorridos en profundidad
especificacion RECORRIDOS-PROF-ARBOLES-BINARIOS[ELEM]
usa ARBOLES-BINARIOS[ELEM], LISTAS[ELEM]operaciones
preorden : arbol-bin −→ listainorden : arbol-bin −→ listapostorden : arbol-bin −→ lista
variables
e : elementoiz , dr : arbol-bin
ecuaciones
preorden(arbol-vacıo) = [ ]preorden(plantar(iz , e, dr )) = [e] ++ (preorden(iz ) ++ preorden(dr ))
inorden(arbol-vacıo) = [ ]inorden(plantar(iz , e, dr )) = inorden(iz ) ++ ([e] ++ inorden(dr ))
postorden(arbol-vacıo) = [ ]postorden(plantar(iz , e, dr )) = postorden(iz ) ++ (postorden(dr ) ++ [e])
fespecificacion
6
Implementacion
fun preorden(a : arbol-bin) dev l : listavar r : lista
si es-arbol-vacıo?(a) entonces l := lista-vacıa()si no
r := preorden(hijo-iz(a))anadir-izq(raız(a), r)l := concatenar(r, preorden(hijo-dr(a)))
fsi
ffun
fun inorden(a : arbol-bin) dev l : listavar r : lista
si es-arbol-vacıo?(a) entonces l := lista-vacıa()si no
r := inorden(hijo-iz(a))anadir-der(r, raız(a))l := concatenar(r, inorden(hijo-dr(a)))
fsi
ffun
7
Version iterativa del recorrido en preorden
Hay que obtener una generalizacion adecuada de la funcion preorden, la operacionpre-lista-pila que, dadas una lista y una pila de arboles binarios, devuelve la concatena-cion de la lista con la concatenacion de los recorridos en preorden de todos los arbolesen la pila.
pre-pila(pila-vacıa) = [ ]pre-pila(apilar(a, p)) = preorden(a) ++ pre-pila(p)
pre-lista-pila(l, p) = l ++ pre-pila(p)
Para calcular el recorrido en preorden de un arbol binario basta considerar la siguienteecuacion:
preorden(a) = pre-lista-pila([ ], apilar(a, pila-vacıa))
8
Para obtener la definicion recursiva de pre-lista-pila, vamos a operar ecuacionalmentecon las ecuaciones anteriores y las que definen el preorden, distinguiendo los tres casossiguientes:
La pila es vacıa.
pre-lista-pila(l, pila-vacıa)= l ++ pre-pila(pila-vacıa)= l ++ [ ]= l
La pila no es vacıa, pero el arbol en su cima es el arbol vacıo.
pre-lista-pila(l, apilar(arbol-vacıo, p))= l ++ pre-pila(apilar(arbol-vacıo, p))= l ++ (preorden(arbol-vacıo) ++ pre-pila(p))= l ++ ([ ] ++ pre-pila(p))= l ++ pre-pila(p)= pre-lista-pila(l, p)
9
La pila no es vacıa y el arbol en su cima no es el arbol vacıo.
pre-lista-pila(l, apilar(plantar(iz , e, dr ), p))= l ++ pre-pila(apilar(plantar(iz , e, dr ), p))= l ++ (preorden(plantar(iz , e, dr )) ++ pre-pila(p))= l ++ (([e] ++ (preorden(iz ) ++ preorden(dr ))) ++ pre-pila(p))= (l ++ [e]) ++ (preorden(iz ) ++ (preorden(dr ) ++ pre-pila(p)))= (l ++ [e]) ++ (preorden(iz ) ++ pre-pila(apilar(dr , p)))= (l ++ [e]) ++ pre-pila(apilar(iz , apilar(dr , p)))= pre-lista-pila(l ++ [e], apilar(iz , apilar(dr , p)))
10
Como la recursion es lineal final en ambos subcasos, la version iterativa se obtienefacilmente, dando lugar al algoritmo siguiente:
fun pre-lista-pila(l : lista, p : pila[arbol-bin] ) dev r : listavar a : arbol-bin, q : pila[arbol-bin]
r := copiar-lista(l) ; q := copiar-pila(p)mientras ¬es-pila-vacıa?(q) hacer
a := cima(q) ; desapilar(q)si ¬es-arbol-vacıo?(a) entonces
anadir-der(r, raız(a))apilar(hijo-dr(a), q)apilar(hijo-iz(a), q)
fsi
fmientras
ffun
11
El recorrido en preorden de un arbol binario se obtiene aplicando la operacion pre-lista-pila a una lista vacıa y una pila que unicamente contiene el arbol a recorrer:
fun preorden-it1(b : arbol-bin) dev r : listavar a : arbol-bin, q : pila[arbol-bin]
r := lista-vacıa()q := pila-vacıa() ; apilar(b, q)mientras ¬es-pila-vacıa?(q) hacer
a := cima(q) ; desapilar(q)si ¬es-arbol-vacıo?(a) entonces
anadir-der(r, raız(a))apilar(hijo-dr(a), q)apilar(hijo-iz(a), q)
fsi
fmientras
ffun
12
fun preorden-it2(b : arbol-bin) dev r : listavar a, h : arbol-bin, q : pila[arbol-bin]
r := lista-vacıa()si ¬es-arbol-vacıo?(b) entonces
q := pila-vacıa() ; apilar(b, q)mientras ¬es-pila-vacıa?(q) hacer
a := cima(q) ; desapilar(q)anadir-der(r, raız(a))h := hijo-dr(a)si ¬es-arbol-vacıo?(h) entonces apilar(h, q) fsih := hijo-iz(a)si ¬es-arbol-vacıo?(h) entonces apilar(h, q) fsi
fmientras
fsi
ffun
13
Recorrido por niveles
especificacion RECORRIDO-NIVELES-ARBOLES-BINARIOS1[ELEM]
usa NATURALES, ARBOLES-BINARIOS+[ELEM], LISTAS[ELEM]
operaciones
niveles : arbol-bin −→ lista
operaciones privadas
nivel-i-esimo : arbol-bin nat −→ lista
niveles-hasta-i-esimo : arbol-bin nat −→ listavariables
a : arbol-bin
i : nat
ecuaciones
niveles(a) = niveles-hasta-i-esimo(a, altura(a))
nivel-i-esimo(arbol-vacıo, i) = [ ]
nivel-i-esimo(plantar(iz , e, dr ), 0) = [ ]
nivel-i-esimo(plantar(iz , e, dr ), 1) = [e]
nivel-i-esimo(plantar(iz , e, dr ), i) = nivel-i-esimo(iz , i− 1) ++ nivel-i-esimo(dr , i− 1) ⇐ i > 1
niveles-hasta-i-esimo(a, 0) = [ ]
niveles-hasta-i-esimo(a, i) = niveles-hasta-i-esimo(a, i− 1) ++ nivel-i-esimo(a, i) ⇐ i > 0fespecificacion
14
especificacion RECORRIDO-NIVELES-ARBOLES-BINARIOS2[ELEM]
usa ARBOLES-BINARIOS[ELEM],COLAS[ARBOLES-BINARIOS[ELEM]], LISTAS[ELEM]
operaciones
niveles : arbol-bin −→ lista
operaciones privadas
niveles-cola : cola[arbol-bin] −→ lista
variables
a : arbol-bin
c : cola[arbol-bin]
ecuaciones
niveles(a) = niveles-cola(pedir-vez(cola-vacıa, a))
niveles-cola(c) = [ ] ⇐ es-cola-vacıa?(c)
niveles-cola(c) = niveles-cola(avanzar(c))
⇐ ¬es-cola-vacıa?(c) ∧ es-arbol-vacıo?(primero(c))
niveles-cola(c) = raız(primero(c)) : niveles-cola(pedir-vez(pedir-vez(avanzar(c),
hijo-iz(primero(c))), hijo-dr(primero(c))))
⇐ ¬es-cola-vacıa?(c) ∧ ¬es-arbol-vacıo?(primero(c))fespecificacion
15
Implementacion iterativa
fun niveles(a : arbol-bin) dev l : listavar sig , hijo : arbol-bin, c : cola[arbol-bin]
l := lista-vacıa()si ¬es-arbol-vacıo?(a) entonces
c := cola-vacıa() ; pedir-vez(c, a)mientras ¬es-cola-vacıa?(c) hacer
sig := primero(c) ; avanzar(c)anadir-der(l, raız(sig))hijo := hijo-iz(sig)si ¬es-arbol-vacıo?(hijo) entonces pedir-vez(c, hijo) fsihijo := hijo-dr(sig)si ¬es-arbol-vacıo?(hijo) entonces pedir-vez(c, hijo) fsi
fmientras
fsi
ffun
16
Arboles generales: especificacion
especificacion ARBOLES-GENERALES[ELEM]usa BOOLEANOS,NATURALEStipos arbol, bosqueoperaciones
plantar : elemento bosque −→ arbol { constructora }bosque-vacıo : −→ bosque { constructora }an-arbol : arbol bosque −→ bosque { constructora }raız : arbol −→ elementohijos : arbol −→ bosquenum-hijos : arbol −→ natlongitud : bosque −→ natsubarbol : arbol nat −→p arbol[ ] : bosque nat −→p arboles-hoja? : arbol −→ bool
17
variables
e : elementoa : arbolb : bosquei : nat
ecuaciones
raız(plantar(e, b)) = e
hijos(plantar(e, b)) = b
num-hijos(plantar(e, b)) = longitud(b)
longitud(bosque-vacıo) = 0longitud(an-arbol(a, b)) = 1 + longitud(b)
subarbol(plantar(e, b), i) = b[i]
b[i] = error ⇐ i == 0 ∨ i > longitud(b)an-arbol(a, b)[1] = a
an-arbol(a, b)[i] = b[i− 1] ⇐ 1 < i ∧ i ≤ longitud(b) + 1
es-hoja?(a) = (num-hijos(a) == 0)fespecificacion
18
Arboles generales: implementacion
tiposenlace-arbol = puntero a nodo-arbolnodo-arbol = reg
valor : elementoprimog , sig-herm : enlace-arbol
freg
arbol = enlace-arbolbosque = enlace-arbol
ftipos
fun plantar(e : elemento, b : bosque) dev a : arbol { Θ(1) }reservar(a)a↑ .valor := e
a↑ .primog := b
a↑ .sig-herm := nilffun
19
fun bosque-vacıo() dev b : bosque { Θ(1) }b := nil
ffun
proc an-arbol(a : arbol, b : bosque) { Θ(1) }a↑ .sig-herm := b
b := a
fproc
fun raız(a : arbol ) dev e : elemento { Θ(1) }e := a↑ .valor
ffun
fun hijos(a : arbol ) dev b : bosque { Θ(1) }b := a↑ .primog
ffun
fun num-hijos(a : arbol ) dev n : natn := longitud(a↑ .primog)
ffun
20
fun longitud(b : bosque) dev n : natvar c : enlace-arbol
c := b ; n := 0mientras c 6= nil hacer
n := n + 1c := c↑ .sig-herm
fmientras
ffun
fun es-hoja?(a : arbol ) dev r : bool { Θ(1) }r := (a↑ .primog = nil)
ffun
21
fun subarbol(a : arbol, i : nat ) dev h : arbol { Θ(i) }h := consultar(a↑ .primog , i)
ffun
fun consultar(b : bosque, i : nat ) dev h : arbol { Θ(i) }si i = 0 entonces error(Indice no valido)si no
h := b ; j := 1mientras h 6= nil ∧ j 6= i hacer
j := j + 1h := h↑ .sig-herm
fmientras
si h = nil entonces error(Indice no valido) fsifsi
ffun
22
Arboles binarios de busqueda
parametro ELEM=<
usa BOOLEANOS,ELEM=operaciones
< : elemento elemento −→ bool> : elemento elemento −→ bool
variables
x, y, z : elementoecuaciones
x < x = falso { antirreflexividad }x < z = cierto ⇐ x < y ∧ y < z { transitividad }x < y ∨ y < x = cierto ⇐ x 6= y { totalidad }
x > y = y < x
fparametro
23
especificacion ARBOLES-BINARIOS-DE-BUSQUEDA[ELEM=<]usa BOOLEANOStipos arbol-bboperaciones
abb-vacıo : −→ arbol-bb { constructora }plantar : arbol-bb elemento arbol-bb −→p arbol-bb { constructora }insertar : elemento arbol-bb −→ arbol-bbesta? : elemento arbol-bb −→ boolmınimo : arbol-bb −→p elementomaximo : arbol-bb −→p elementoeliminar : elemento arbol-bb −→ arbol-bbes-abb-vacıo? : arbol-bb −→ bool
variables
e, f : elementoiz , dr : arbol-bb
ecuaciones
plantar(iz , e, dr ) = error ⇐ ¬(es-abb-vacıo?(iz ) ∨ e > maximo(iz )) ∨¬(es-abb-vacıo?(dr ) ∨ e < mınimo(dr ))
24
insertar(e, abb-vacıo) = plantar(abb-vacıo, e, abb-vacıo)insertar(e, plantar(iz , e, dr )) = plantar(iz , e, dr )insertar(e, plantar(iz , f, dr )) = plantar(insertar(e, iz ), f, dr ) ⇐ e < f
insertar(e, plantar(iz , f, dr )) = plantar(iz , f, insertar(e, dr )) ⇐ e > f
esta?(e, abb-vacıo) = falsoesta?(e, plantar(iz , e, dr )) = ciertoesta?(e, plantar(iz , f, dr )) = esta?(e, iz ) ⇐ e < f
esta?(e, plantar(iz , f, dr )) = esta?(e, dr ) ⇐ e > f
mınimo(abb-vacıo) = errormınimo(plantar(abb-vacıo, e, dr )) = e
mınimo(plantar(iz , e, dr )) = mınimo(iz ) ⇐ ¬es-abb-vacıo?(iz )
maximo(abb-vacıo) = errormaximo(plantar(iz , e, abb-vacıo)) = e
maximo(plantar(iz , e, dr )) = maximo(dr ) ⇐ ¬es-abb-vacıo?(dr )
25
eliminar(e, abb-vacıo) = abb-vacıoeliminar(e, plantar(iz , e, abb-vacıo)) = iz
eliminar(e, plantar(abb-vacıo, e, dr )) = dr
eliminar(e, plantar(iz , e, dr )) = plantar(iz , mınimo(dr ), eliminar(mınimo(dr ), dr ))⇐ ¬es-abb-vacıo?(iz ) ∧ ¬es-abb-vacıo?(dr )
eliminar(e, plantar(iz , f, dr )) = plantar(eliminar(e, iz ), f, dr )) ⇐ e < f
eliminar(e, plantar(iz , f, dr )) = plantar(iz , f, eliminar(e, dr )) ⇐ e > f
es-abb-vacıo?(abb-vacıo) = ciertoes-abb-vacıo?(plantar(iz , e, dr )) = falso
fespecificacion
26
Implementacion
tiposenlace-abb = puntero a nodo-abbnodo-abb = reg
valor : elementoiz , dr : enlace-abb
freg
arbol-bb = enlace-abbftipos
fun abb-vacıo() dev a : arbol-bb { Θ(1) }a := nil
ffun
27
proc insertar(e e : elemento, a : arbol-bb) { Θ(altura(a)) }si a = nil entonces
reservar(a)a↑ .valor := e
a↑ .iz := nil ; a↑ .dr := nilsi no
casos
e = a↑ .valor → nada
e < a↑ .valor → insertar(e, a↑ .iz )e > a↑ .valor → insertar(e, a↑ .dr )
fcasos
fsi
fproc
{ (es-abb-vacıo?(iz ) ∨ maximo(iz ) < e) ∧ (es-abb-vacıo?(dr ) ∨ e < mınimo(dr )) }fun plantar(iz : arbol-bb, e : elemento, dr : arbol-bb) dev a : arbol-bb { Θ(1) }
reservar(a)a↑ .valor := e
a↑ .iz := iz ; a↑ .dr := dr
ffun
28
fun esta?(e : elemento, a : arbol-bb) dev b : bool { Θ(altura(a)) }si a = nil entonces b := falsosi no
casos
e = a↑ .valor → b := ciertoe < a↑ .valor → b := esta?(e, a↑ .iz )e > a↑ .valor → b := esta?(e, a↑ .dr )
fcasos
fsi
ffun
fun mınimo(a : arbol-bb) dev e : elemento { Θ(altura(a)) }si a = nil entonces error(Arbol vacıo)si no
si a↑ .iz = nil entonces e := a↑ .valor
si no e := mınimo(a↑ .iz )fsi
fsi
ffun
29
fun maximo(a : arbol-bb) dev e : elemento { Θ(altura(a)) }si a = nil entonces error(Arbol vacıo)si no
si a↑ .dr = nil entonces e := a↑ .valor
si no e := maximo(a↑ .dr )fsi
fsi
ffun
fun es-abb-vacıo?(a : arbol-bb) dev b : bool { Θ(1) }b := (a = nil)
ffun
30
proc eliminar(e e : elemento, a : arbol-bb) { Θ(altura(a)) }var b : enlace-abb
si a 6= nil entoncescasos
e = a↑ .valor →casos
a↑ .dr = nil → b := a ; a := a↑ .iz ; liberar(b)a↑ .iz = nil → b := a ; a := a↑ .dr ; liberar(b)a↑ .dr 6= nil ∧ a↑ .iz 6= nil → eliminar-aux(a, a↑ .dr )
fcasos
e < a↑ .valor → eliminar(e, a↑ .iz )e > a↑ .valor → eliminar(e, a↑ .dr )
fcasos
fsi
fproc
31
{ a 6= nil ∧ b 6= nil }proc eliminar-aux(a, b : arbol-bb) { Θ(altura(b)) }var c : enlace-abb
si b↑ .iz 6= nil entonces eliminar-aux(a, b↑ .iz )si no
a↑ .valor := b↑ .valor
c := b ; b := b↑ .dr
liberar(c)fsi
fproc
32
Arboles binarios de busqueda de pares clave-valor
parametro CLAVESusa BOOLEANOStipos claveoperaciones
== : clave clave −→ bool6= : clave clave −→ bool
variables
c, d, e : claveecuaciones
(x == y) = cierto ⇐ x = y
x = y ⇐ (x == y) = ciertox 6= y = ¬(x == y)
fparametro
33
parametro CLAVES<usa CLAVESoperaciones
< : clave clave −→ bool> : clave clave −→ bool
variables
c, d, e : claveecuaciones
c < c = falso { antirreflexividad }c < e = cierto ⇐ c < d ∧ d < e { transitividad }c < d ∨ d < c = cierto ⇐ c 6= d { totalidad }
c > d = d < c
fparametro
parametro VALORES-MODIFICABLEStipos valoroperaciones
combinar : valor valor −→ valorfparametro
34
especificacion ABB-CON-PARES[CLAVES<, VALORES-MODIFICABLES]usa BOOLEANOStipos arbol-bboperaciones
abb-vacıo : −→ arbol-bb { constructora }plantar : arbol-bb clave valor arbol-bb −→p arbol-bb { constructora }insertar : clave valor arbol-bb −→ arbol-bbconsultar : clave arbol-bb −→p valoresta? : clave arbol-bb −→ boolmınimo : arbol-bb −→p clavemaximo : arbol-bb −→p claveeliminar : clave arbol-bb −→ arbol-bbes-abb-vacıo? : arbol-bb −→ bool
variables
c, d : clavev, w : valoriz , dr : arbol-bb
35
ecuaciones
plantar(iz , c, v, dr ) = error⇐ ¬(es-abb-vacıo?(iz ) ∨ c > maximo(iz )) ∨¬(es-abb-vacıo?(dr ) ∨ c < mınimo(dr ))
insertar(c, v, abb-vacıo) = plantar(abb-vacıo, c, v, abb-vacıo)insertar(c, v, plantar(iz , c, w, dr )) = plantar(iz , c, combinar(w, v), dr )insertar(c, v, plantar(iz , d, w, dr )) = plantar(insertar(c, v, iz ), d, w, dr ) ⇐ c < d
insertar(c, v, plantar(iz , d, w, dr )) = plantar(iz , d, w, insertar(c, v, dr )) ⇐ c > d
consultar(c, abb-vacıo) = errorconsultar(c, plantar(iz , c, v, dr )) = v
consultar(c, plantar(iz , d, w, dr )) = consultar(c, iz ) ⇐ c < d
consultar(c, plantar(iz , d, w, dr )) = consultar(c, dr ) ⇐ c > d
esta?(c, abb-vacıo) = falsoesta?(c, plantar(iz , c, v, dr )) = ciertoesta?(c, plantar(iz , d, w, dr )) = esta?(c, iz ) ⇐ c < d
esta?(c, plantar(iz , d, w, dr )) = esta?(c, dr ) ⇐ c > d
36
mınimo(abb-vacıo) = errormınimo(plantar(abb-vacıo, c, v, dr )) = c
mınimo(plantar(iz , c, v, dr )) = mınimo(iz ) ⇐ ¬es-abb-vacıo?(iz )
maximo(abb-vacıo) = errormaximo(plantar(iz , c, v, abb-vacıo)) = c
maximo(plantar(iz , c, v, dr )) = maximo(dr ) ⇐ ¬es-abb-vacıo?(dr )
eliminar(c, abb-vacıo) = abb-vacıoeliminar(c, plantar(iz , c, v, abb-vacıo)) = iz
eliminar(c, plantar(abb-vacıo, c, v, dr )) = dr
eliminar(c, plantar(iz , c, v, dr )) = plantar(iz , mınimo(dr ), consultar(mınimo(dr )),eliminar(mınimo(dr ), dr ))
⇐ ¬es-abb-vacıo?(iz ) ∧ ¬es-abb-vacıo?(dr )eliminar(c, plantar(iz , d, w, dr )) = plantar(eliminar(c, iz ), d, w, dr ) ⇐ c < d
eliminar(c, plantar(iz , d, w, dr )) = plantar(iz , d, w, eliminar(c, dr )) ⇐ c > d
es-abb-vacıo?(abb-vacıo) = ciertoes-abb-vacıo?(plantar(iz , c, v, dr )) = falso
fespecificacion
37
Implementaciontipos
enlace-abb = puntero a nodo-abbnodo-abb = reg
clave : clavevalor : valoriz , dr : enlace-abb
freg
arbol-bb = enlace-abbftipos
fun consultar(c : clave, a : arbol-bb) dev v : valor { Θ(altura(a)) }si a = nil entonces error(Clave no definida)si no
casos
c = a↑ .clave → v := a↑ .valor
c < a↑ .clave → v := consultar(c, a↑ .iz )c > a↑ .clave → v := consultar(c, a↑ .dr )
fcasos
fsi
ffun38
proc insertar(e c : clave, e v : valor, a : arbol-bb) { Θ(altura(a)) }si a = nil entonces
reservar(a)a↑ .clave := c ; a↑ .valor := v ; a↑ .iz := nil ; a↑ .dr := nil
si no
casos
c = a↑ .clave → combinar(a↑ .valor , v)c < a↑ .clave → insertar(c, v, a↑ .iz )c > a↑ .clave → insertar(c, v, a↑ .dr )
fcasos
fsi
fproc
39
Arboles equilibrados
fun altura(a : arbol-bin) dev alt : natsi es-arbol-vacıo?(a) entonces alt := 0si no alt := 1 +max(altura(hijo-iz(a)), altura(hijo-dr(a)))fsi
ffun
Talt(n) =
c0 n = 0Talt(p) + Talt(q) + c1 n > 0
fun diferencia(n, m : nat ) dev d : natsi n ≥ m entonces d := n−m
si no d := m− n
fsi
ffun
40
fun equilibrado(a : arbol-bin) dev eq : boolsi es-arbol-vacıo?(a) entonces eq := ciertosi no eq := equilibrado(hijo-iz(a)) ∧ equilibrado(hijo-dr(a)) ∧
(diferencia(altura(hijo-iz(a)), altura(hijo-dr(a))) ≤ 1)fsi
ffun
Teq(n) =
c′0 n = 0Teq(p) + Teq(q) + c′1n n > 0
41
fun equilibrado2(a : arbol-bin) dev 〈 eq : bool, alt : nat 〉si es-arbol-vacıo?(a) entonces 〈 eq , alt 〉 := 〈 cierto, 0 〉si no
〈 eq-iz , alt-iz 〉 := equilibrado2(hijo-iz(a))〈 eq-dr , alt-dr 〉 := equilibrado2(hijo-dr(a))eq := eq-iz ∧ eq-dr ∧ (diferencia(alt-iz , alt-dr ) ≤ 1)alt := 1 +max(alt-iz , alt-dr )
fsi
ffun
Teq2(n) =
c′′0 n = 0Teq2(p) + Teq2(q) + c′′1 n > 0
42
top related