Ar Boles
Ar Boles
Ar Boles
Informtica Gestin
rboles Definiciones
Arbol: Un arbol consiste en un nodo (r, llamado nodo raiz) y una lista o
coleccin de subrboles (A1, A2, ... , Ak). Si el orden de los subrboles
importa, entonces se representan como una lista, y se denomina rbol
ordenado. En caso contrario se representan como una coleccin y se
denomina arbol no ordenado.
Se definen como nodos hijos de r a los los nodos raices de los subrboles
A1, A2, ... , Ak
Representacin de rboles
Las operaciones principales son el acceso al nodo padre, a los nodos hijos,
la insercin y borrado de subrboles hijos y el cambio del cursor.
Ejemplo:
Raiz
a /
a /
b c d
b c d /
e f / /
g
e f /
/
Cursor
g /
/
Variantes de rboles
rbol binario: rbol que consta de un nodo raiz y de dos subrboles,
llamados subrbol izquierdo y subrbol derecho. Se permite que existan
rboles vacos (sin ningn nodo, ni siquiera el raiz). Los subrboles vacos
tienen altura 1.
i div 2
2 3
i
4 5 6 7
2i 2i+1
8 9 10 11 12
1
0
1 1
-1 +1
0 0 1
0 0
ESPECIFICACIN ARBOL
USA LISTA_INDEXADA
PARMETROS
GENEROS nodo
OPERACIONES
: nodo { Nodo nulo }
= , : nodo, nodo booleano { Relacin de igualdad }
FIN_PARMETROS
GENEROS arbol
OPERACIONES
: nodo, lista[arbol] arbol { creacin de un arbol }
raiz : arbol nodo { nodo raiz de un arbol }
PARCIAL subarbol : arbol, natural nodo { subarbol n-simo de un arbol }
PARCIAL padre : arbol, nodo nodo { nodo padre de un nodo del arbol }
PARCIAL hijos : arbol, nodo lista[nodo] { nodos hijos de un nodo del arbol }
AUXILIAR : nodo, arbol booleano { pertenencia de un nodo a un arbol }
VARIABLES
a : arbol; x, y : nodo; i : natural; l, l1, l2 : lista[arbol];
DEFINIBILIDAD
(x a) DEF [ padre( a, x ) ]
(x a) DEF [ hijos( a, x ) ]
ECUACIONES
raiz( x l ) == x
subarbol( x l, i ) == l @ i
x (x l) == T
( x y ) x (y [ ]) == F
( x y ) x (y a >> l) == ( x a ) ( x (y l) )
padre( x l, x ) ==
padre( y (x l1) >> l2, x ) == y
( x y ) ( x a ) padre( y a >> l, x ) == padre( a, x )
( x y ) ( x a ) padre( y a >> l, x ) == padre( y l, x )
hijos( x [ ], x ) == [ ]
hijos( x a >> l, x ) == raiz(a) >> hijos( x l, x )
( x y ) ( x a ) hijos( y a >> l, x ) == hijos( a, x )
( x y ) ( x a ) hijos( y a >> l, x ) == hijos( y l, x )
FIN_ESPECIFICACIN
ESPECIFICACIN ARBOLES_OPERACIONES
USA ARBOL
OPERACIONES
altura : arbol natural
PARCIAL altura_nodo : arbol, nodo natural
PARCIAL profundidad : arbol, nodo natural
PARCIAL hoja : arbol, nodo booleano
VARIABLES
a : arbol; x,y : nodo; l : lista[arbol]
DEFINIBILIDAD
(x a) DEF [ altura_nodo( a, x ) ]
(x a) DEF [ profundidad( a, x ) ]
(x a) DEF [ hoja( a, x ) ]
ECUACIONES
altura( x [ ] ) == 0
altura( x a >> l ) == max( 1+altura( a ), altura( x l ) )
altura_nodo( x l, x ) == altura( x l )
( x y ) ( x a ) altura_nodo( y a >> l, x ) == altura_nodo( a, x )
( x y ) ( x a ) altura_nodo( y a >> l, x ) == altura_nodo( y l, x )
profundidad( x l, x ) == 0
( x y ) ( x a ) profundidad( y a >> l, x ) == 1+profundidad( a, x )
( x y ) ( x a ) profundidad( y a >> l, x ) == profundidad( y l, x )
hoja( x [ ], x ) == T
hoja( x a >> l, x ) == F
( x y ) ( x a ) hoja( y a >> l, x ) == hoja( a, x )
( x y ) ( x a ) hoja( y a >> l, x ) == hoja( y l, x )
FIN_ESPECIFICACIN
Elevacin de un nodo:
Mdulo Elevar
{ Reorganiza un montculo en el que, al cambiar de valor un nodo, es
posible que ya no se cumpla la propiedad de monticulo para los
ascendientes de ese nodo. El algoritmo consiste en intercambiar el
nodo con sus ascendientes hasta restablecer la propiedad. }
Entradas
{ El montculo se representa por un vector que almacena sus elementos
en el orden de un recorrido por niveles. El vector tiene una
capacidad mxima de Max elementos, y en un momento dado almacena
nicamente N elementos en los ndices 1..N }
V : vector[1..Max] de tipo_elemento
N : entero
I : entero { ndice del nodo que ha cambiado. 1 I N }
Salidas
V : vector[1..Max] de tipo_elemento
Variables
Padre, Hijo : enteros
Seguir : booleano
Inicio
Hijo I
Seguir Cierto
Mientras (Hijo > 1) Y Seguir hacer
Padre Hijo div 2
Si V[Padre].Clave < V[Hijo].Clave entonces
{ Intercambiar nodo padre con el nodo hijo y seguir comprobando }
V[Hijo] V[Padre]
Hijo Padre
Sino
Seguir Falso
Fin_Si
Fin_Mientras
Fin
Reestructuracin de un (sub)montculo:
Mdulo Reestructurar
{ Reorganiza un montculo en el que, al cambiar de valor un nodo, es
posible que ya no se cumpla la propiedad de monticulo para los
descendientes de ese nodo. Alternativamente, esta operacin se
puede contemplar como reorganizar un (sub)montculo cuya raiz es
el nodo I, donde todos los nodos excepto la raiz cumplen la
propiedad de montculo. El algoritmo consiste en intercambiar el
nodo con sus descendientes hasta restablecer la propiedad. }
Entradas
{ El montculo se representa por un vector que almacena sus elementos
en el orden de un recorrido por niveles. El vector tiene una
capacidad mxima de Max elementos, y en un momento dado almacena
nicamente N elementos en los ndices 1..N }
V : vector[1..Max] de tipo_elemento
N : entero
I : entero { ndice del nodo raiz del submontculo. 1 I N }
Salidas
V : vector[1..Max] de tipo_elemento
Variables
Padre, Hijo : enteros
Seguir : booleano
Inicio
Padre I
Hijo 2*Padre { Hijo izquierdo }
Seguir Cierto
Mientras (Hijo N) Y Seguir hacer
{ Comprobar cual es el hijo con clave mayor }
Si Hijo < N entonces { existe hijo derecho }
Si V[Hijo+1].Clave > V[Hijo].Clave entonces
Hijo Hijo+1
Fin_Si
Fin_Si
{ Comprobar si el hijo mayor tiene una clave mayor que el padre }
Si V[Hijo].Clave > V[Padre].Clave entonces
{ Intercambiar nodo padre con el nodo hijo y seguir comprobando }
V[Padre] V[Hijo]
Padre Hijo
Hijo 2*Padre
Sino
Seguir Falso
Fin_Si
Fin_Mientras
Fin
Modificacin de un nodo:
Mdulo Modificar
Entradas
V : vector[1..Max] de tipo_elemento
N : entero { nmero de elementos del montculo }
I : entero { ndice del elemento que cambia }
E : tipo_elemento { nuevo valor del elemento }
Salidas
V : vector[1..Max] de tipo_elemento
Inicio
Si E.Clave > V[I].Clave entonces
{ Slo puede afectar a los ascendientes del nodo que cambia }
V[I] E
Ascender(V,N,I; V)
Sino
{ Slo puede afectar a los descendientes del nodo que cambia }
V[I] E
Reestructurar(V,N,I; V)
Fin-Si
Fin
Creacin de un montculo:
Mdulo Crear
{ Reorganiza un vector desordenado de forma que pueda representar
a un montculo. Eficiencia: O(n) }
Entradas
V : vector[1..Max] de tipo_elemento
N : entero { nmero de elementos del vector }
Salidas
V : vector[1..Max] de tipo_elemento
Variables
I : entero
Inicio
{ Realiza una secuencia de reestructuraciones desde los niveles
inferiores (comenzando por el padre del ltimo nodo) hasta
la raiz. }
Para I N div 2 hasta 1 incr -1
Reestructurar(V,N,I; V)
Fin-Para
Fin
2
x 0
y
1 0
y x
h A h+3 h+2
C h+1
h B C h+1 A h B
2
x -1
y
0 1
y x
h A h+3 h+3
C h+1
B h+1 C h A h+1
B
2 0
x z
-1/0 0/1
-1 x y
y
h+2
A h
-1/0/1
z
h+3 D h A h B C h D
B h C
-2 0
x y
0
-1
x
y
C h h+3 h+2
A h+1
A B h
B h C
h+1
-2
1
x y
0 -1
x
y
C h
h+3 h+3
A h+1
A B B h+1 C h
h+1
-2 0
x z
-1/0 0/1
1
y x
y
h+2
h D
-1/0/1
z
h A h+3 A h B C h D
B h C
Tablas de Dispersin
h(k) = k
h(k1) = h(k2), k1 k2
Tamao de la lista 0 1 2 3 4 5
h(dni) = dni div 100000: (Usa los 3 primeros dgitos del DNI)
i0 h(k) ; i fm (i0,0) ; j 1
MIENTRAS tabla[i] no vaca Y tabla[i].clave k HACER
Acceso
i fm (i0 , j) ; j j + 1
FIN_MIENTRAS
MIENTRAS
i fm (i0 , j) ; j j + 1
FIN_MIENTRAS
tabla[i] elem ; quitar marca de borrado (si existe)
i0 h(k) ; i fm (i0,0) ; j 1
MIENTRAS tabla[i].clave k O tabla[i] borrada HACER
Borrado
i fm (i0 , j) ; j j + 1
FIN_MIENTRAS
marcar tabla[i] como borrada
Funciones de Exploracin
Las funciones de exploracin ms utilizadas son la exploracin lineal,
cuadrtica y con desplazamiento cociente (tambien llamada doble
dispersin):
Insercin 0 ln(1/(1-L))/L
o Ajustar el tamao de la tabla para que el factor de carga este dentro de unos lmites
tolerables. En el caso de dispersin cerrada es obligatorio reestructurar la tabla
cuando el factor de carga se aproxime a la unidad.
ESPECIFICACIN DICCIONARIO_ELEM_NICO
PARMETROS
GENEROS clave, elemento
OPERACIONES
= , : clave, clave booleano { Relacin de igualdad entre claves }
FIN_PARMETROS
GENEROS diccionario1
OPERACIONES
crear : diccionario1 { creacin de un diccionario vaco }
aadir : diccionario1, clave, elemento : diccionario { insercin y modificacin }
borrar : diccionario1, clave diccionario { borrado }
presente : diccionario1, clave booleano { existencia de par clave-elemento }
PARCIAL valor : diccionario1, clave elemento { acceso }
VARIABLES
k, k1, k2 : clave
e, e1, e2 : elemento
d : diccionario1
DEFINIBILIDAD
presente( d, k ) DEF [ valor( d, k ) ]
ECUACIONES
borrar( crear, k ) == crear
borrar( aadir( d, k, e ), k ) == borrar( d, k )
( k1 k2 ) borrar( aadir( d, k1, e ), k2 ) == aadir( borrar( d, k2 ), k1, e )
presente( crear, k ) == F
presente( aadir( d, k, e ), k ) == T
( k1 k2 ) presente( aadir( d, k1, e ), k2 ) == presente( d, k2 )
valor( aadir( d, k, e ), k ) == e
( k1 k2 ) valor( aadir( d, k1, e ), k2 ) == valor( d, k2 )
FIN_ESPECIFICACIN
ESPECIFICACIN DICCIONARIO_ELEM_MULTIPLE
USA LISTA_BASE
PARMETROS
GENEROS clave, elemento
OPERACIONES
= , : clave, clave booleano { Relacin de igualdad entre claves }
= , : elemento, elemento booleano { Relacin de igualdad entre elementos }
FIN_PARMETROS
GENEROS diccionario2
OPERACIONES
crear : diccionario2 { creacin de un diccionario vaco }
aadir : diccionario2, clave, elemento : diccionario { insercin }
borrar : diccionario2, clave diccionario { borrado de todos los elementos
asociados a la misma clave }
quitar : diccionario2, clave, elemento : diccionario { borrado de elemento concreto }
valor : diccionario2, clave lista { acceso a elems. asociados a clave }
VARIABLES
k, k1, k2 : clave
e, e1, e2 : elemento
d : diccionario2
ECUACIONES
borrar( crear, k ) == crear
borrar( aadir( d, k, e ), k ) == borrar( d, k )
( k1 k2 ) borrar( aadir( d, k1, e ), k2 ) == aadir( borrar( d, k2 ), k1, e )
quitar( crear, k, e ) == crear
quitar( aadir( d, k, e ), k, e ) == quitar( d, k, e )
( e1 e2 ) borrar( aadir( d, k1, e1 ), k2, e2) == aadir( quitar( d, k2, e2 ), k1, e1 )
valor( crear, k ) == [ ]
valor( aadir( d, k, e ), k ) == e >> valor( d, k )
( k1 k2 ) valor( aadir( d, k1, e ), k2 ) == valor( d, k2 )
FIN_ESPECIFICACIN
P_CONTAINER
P_SEARCHABLE
P_SET P_TABLE[G, K]
HASHABLE