Árboles B y B+
Tema 6: Árboles B y B
+
ón mediante índices de grandes volú 1.Gestió 1.Gesti volúmenes de informació información Árboles B 2.Á 2. 3.Acceso 3. Acceso secuencial indexado: Árboles B+
1
Árboles B y B+
Gestión mediante í ndices Gestió ndices de grandes úmenes de informació volú vol información Los índices simples proporcionan un método sencillo y eficiente para manejar ficheros de registros Pero ¿Que ocurre si el volúmen del fichero es tal que los índices no pueden mantenerse en memoria? Mantener un índice simple en disco, aunque posible, es extremadamente ineficiente Las inserciones deben ser ordenadas, y por tanto implican abrir huecos y desplazar registros Los borrados implican eliminar huecos (en el fichero índice no puede utilizarse el borrado ló lógico) Las bú búsquedas binarias requieren demasiados accesos. Buscar un registro entre 1000000 registros → ≃20 accesos 2
Árboles B y B+
Una posible alternativa consiste ordenar lógicamente los registros siguiendo un esquema de árbol binario de búsqueda Izq
AbbChi01 BeaMyb01 BeaC BeaCal al01 01 AbbF AbbFer er01 01
PriI PriIwa wa01 01
BeaT BeaTha ha01 01
BeaS BeaShe he01 01
EagT EagThe he01 01
BobL BobLik ik01 01
RoxLov01
BeaShe02 FleSar01 QueWea01 EagHot01
Representació Representaci ón lógica
Der
Clave
Resto de campos...
0
-1
34 AbbChi01 |
Chiquitita|Abba|1979|3:34
34
68
68
170
102
204 204
136 136 PriIw riIwa0 a01 1 |
I Wan Wanna na Be Be You Your r Lov Lover er|P |Pri rinc nce| e|19 1979 79|1 |1:4 :40 0
136
-1
306 EagThe01 |
The Long Run|Eagles|1979|1:15
170
-1
-1 AbbFer01 |
204
272
238 BeaTha01 |
Thank Yo You Gi Girl|Beatles|1964|2:07
238
272 272
340 340 BobLi obLik0 k01 1 |
Like ike A Roll Rollin ing g Ston Stone| e|Bo Bob b Dyla Dylan| n|19 1965 65|1 |1:2 :28 8
272
-1
-1 BeaShe01 |
She Lo Loves You You|Beatles|1964|3:36
306
408
-1 RoxLov01 |
Love Is The Drug|Roxy Music|1976|3:03
340
374
-1 FleSar01 |
Sara|Fleetwood Mac Mac|1979|2:13
374
-1
-1 EagHot01 |
Hotel California|Eagles|1977|3:28
408
-1
-1 QueWea01 |
We Are The Champions|Queen|1977|2:16
442
-1
-1 BeaShe02 |
She's A Woman|Beatles|1964|3:50
102 BeaM eaMyb01 yb01 | My Bon Bonn nie|B ie|Be eatl atles| es|196 1964|3 4|3:45 :45 -1 BeaCal01 | California Gi Girls|Beach Bo Boys|1965|1:27
Fernando|Abba|1976|3:35
Representació Representaci ón fí sica sica
3
Árboles B y B+
Una pequeña cabecera en el fichero indica la posición del nodo raiz del árbol Los nodos hoja son aquellos cuyos índices izquierda y derecha apuntan a -1 Representación muy compacta: tanto los datos como los índices están almacenados en un único fichero Operaciones muy eficientes Una bú búsqueda implica só sólo O(log n) lecturas en el fichero No es necesario ordenar fí físicamente los datos. Los datos se insertan al final y se enganchan al nodo hoja correspondiente en O(log n) Los borrados aunque un poco má más complejos, tambié también requieren O(log n) lecturas
4
Árboles B y B+
Problema grave: desequilibrado del árbol tras varias inserciones y borrados Solució Solución posible: utilizar un árbol balanceado (p. e. AVL), aunque resolver las rotaciones en el fichero requiere nuevos accesos
La búsqueda binaria no es suficientemente eficiente El uso del disco es muy deficiente Cada acceso implica leer un bloque, y de este bloque únicamente se utiliza un registro, cuyos índices izquierda y derecha apuntan, con mucha probabilidad, a un registro de otro bloque
5
Árboles B y B+
Los índices multinivel hacen multinivel hacen un uso del disco mucho más eficiente que los árboles binarios Se define un registro de claves, de tamañ tamaño igual a un bloque de disco o un divisor de éste El índice de primer nivel consiste en un fichero de registros de claves con apuntadores al fichero de datos El índice de segundo nivel sirve para indexar el índices de primer nivel y tiene la misma estructura que éste. Cada entrada aquí aquí incluye la clave de la primera entrada de cada registro del índice de primer nivel y un apuntador a éste El índice de tercer nivel indexa al de segú segúndo nivel, etc. Fichero í ndice ndice de segundo nivel AbbChi01|BeaShe01|EagHot01
...
Fichero í ndice ndice de primer nivel AbbChi01|AbbFer01|BeaCal1|BeaMyb01 AbbChi01|AbbFer01 AbbChi01|AbbFer01|BeaCal1|BeaMyb01 |BeaCal1|BeaMyb01
BeaShe01|BeaShe02|BeaTha01|BobLik01 BeaShe01|BeaShe02| BeaTha01|BobLik01 EagHot01|EagThe01|FleSar01|PriIwa01 EagHot01|EagThe01|FleSar01|PriIwa01
Fichero de datos
...
6
Árboles B y B+
La búsqueda en un índice multinivel es muy eficiente, ya que requiere un único acceso por cada nivel Buscar la clave en el registro del índice de mayor nivel mediante bú búsqueda binaria Obtenemos una entrada cuya clave puede ser igual o inmediantemente inferior a la buscada. Seguimos el apuntador al bloque del siguiente s iguiente nivel y repetimos este proceso hasta llegar al fichero de datos
Los índice multinivel son esencialmente una estructura de ficheros estática. Las inserciones y borrados son costosos La inserció inserción requiere recorrer los distintos niveles insertando una nueva clave en los registros de índices correspondientes. Esto implica abrir un hueco moviendo índices al siguiente registro en cascada c ascada El borrado deja huecos que deben ser eliminado siguiendo un proceso similar
7
Árboles B y B+
Árboles B Descubiertos Descubiertos en 1972 por Bayer y McCreight, McCreight, son el estándar hoy en día para la indexación de ficheros de datos Los árboles B son B son índices multinivel que resuelven los problemas de la inserción y borrado de registros y se basan en dos reglas Permitir que los registros índice no esté estén llenos No mover índices de un registro a otro cuando está está lleno. En su lugar, dividir en dos el registro. Cuando dos registros está están muy vací vacíos, unirlos en uno solo
Cada registro de claves es un nodo del árbol B El nú número má máximo de claves por nodo (m (m ) constituye el orden del árbol B El nú número mí mínimo de claves permitidas en un nodo es normalmente la mitad del orden del árbol, con la excepció excepción de la raiz
8
Árboles B y B+
Dos propiedades de las hojas: Todas las hojas tienen la misma profundidad (pertenecen al mismo nivel) Las hojas poseen apuntadores a los registros en el fichero de datos, de forma que el nivel completo de las hojas forma un índice ordenado del fichero de datos
El árbol B se guarda íntegramente en un único fichero índice, de manera similar al árbol binario estudiado anteriormente AbbChi01|BeaMyb01|BeaTha01|PriIwa01
PriIwa01|QueWea01|RoxLov01 AbbChi01|AbbFer01|BeaCal01
BeaMyb01|BeaShe01|BeaShe02
BeaTha01|BobLik01|EagHot01|FleSar01
Fichero de datos 9
Árboles B y B+
B ú rbol B úsqueda squeda en un á rbol
La búsqueda en un árbol B es tan eficiente como en un índice multinivel, con un orden O(log m n), n), siendo m el orden del árbol y n el el número de elementos Para un fichero de 1000000 de datos indexado mediante un árbol B de orden 10 localizamos cualquier dato con 6 accesos
El procedimiento de búsqueda es el siguiente 1 Comenzar por el nodo raiz. Se lee de disco a memoria si es necesario 2 Realizar una bú búsqueda binaria o secuencial para localizar la clave k igual igual o inmediatamente inmediatamente inferior al valor de la clave bú b úscada. Obtener la direcció dirección d asociada asociada a dicha clave 3 Si el nodo anterior no es una hoja, leer el siguiente nodo, apuntado por la direcció dirección d y y pasarlo a memoria. Volver al paso 2 4 En caso contrario leer el registro del fichero de datos apuntado por la direcció dirección d
10
Árboles B y B+
Inserci ó rbol B ón en un á rbol
La inserción de una clave se s e realiza mediante dos pasadas: Una pasada hacia abajo en la que se realiza una bú búsqueda para encontrar la hoja que le corresponde a la clave Una pasada hacia arriba en la que se dividen los nodos cuando es necesario
Los pasos a seguir son los siguientes 1 Realizar la bú búsqueda del nodo hoja que corresponde a la clave 2 Insertar la clave en el nodo inserción no es posible por estar el nodo lleno, crear un nuevo nodo y pasar a 3 Si la inserció éste la mitad de las claves. Realizar la inserció inserción de la clave en el nodo que le corresponda 4 Si la clave insertada es la menor del nodo, actualizar la clave en el nodo padre (y realizar lo mismo, si es necesario, hasta la raiz) 5 Si se ha dividido el nodo original, insertar la primera clave del nuevo nodo en el nodo padre (para ello volver al paso 2)
11
Árboles B y B+
Ejemplo: AbbChi01|BeaCal01
AbbChi01|AbbFer01
BeaCal01|BeaShe01|BeaShe02|BeaTha01
Insertar AbbSar02 . El nodo se inserta sin problemas AbbChi01|BeaCal01
AbbC AbbChi hi01 01|A |Abb bbFe Fer0 r01| 1|Ab AbbS bSar ar02 02
BeaC BeaCal al01 01|B |Bea eaSh She0 e01| 1|Be BeaS aShe he02 02|B |Bea eaTh Tha0 a01 1
Insertar AbbCas01. AbbCas01. El nodo se inserta sin problemas, aunque al situarse en primera posició posición es necesario actualizar la clave del padre AbbCas01|BeaCal01
AbbCas01| AbbCas01|AbbCh AbbChi01| i01|AbbFe AbbFer01|A r01|AbbSar bbSar02 02
BeaCal01| BeaCal01|BeaS BeaShe01| he01|BeaS BeaShe02| he02|BeaT BeaTha01 ha01
12
Árboles B y B+
Insertar BeaShe03 . No hay espacio en el nodo, por tanto es necesario dividir y redistribuir las claves. La clave se inserta en el segundo nodo
AbbCas01|BeaCal01|BeaShe02
AbbCas01|AbbChi01|AbbFer01|AbbSar02
BeaCal01|BeaShe01
BeaShe02|BeaShe03|BeaTha01
Insertar AbbBet01. AbbBet01. Una situació situación que combina las dos anteriores
AbbBet01|AbbFer01|BeaCal01|BeaShe02
AbbBet01|AbbCas01|AbbChi01
AbbFer01|AbbSar02
BeaShe02|BeaShe03|BeaTha01
BeaCal01|BeaShe01
13
Árboles B y B+
Borrado en un á rbol rbol B
El borrado también requiere dos pasadas Una pasada hacia abajo en la que se realiza una bú búsqueda para encontrar la hoja que contiene la clave Una pasada hacia arriba en la que se unen nodos cuando su ocupació ocupación baja del umbral permitido y se redistribuyen claves cuando lo anterior no es posible
Los pasos a seguir son los siguientes 1 Realizar la bú búsqueda del nodo hoja que contiene la clave 2 Eliminar la clave del nodo 3 Si la ocupació ocupación del nodo es superior a m/2 y la clave ocupaba la primera posició posición del nodo, actualizar los nodos de niveles superiores estableciendo una nueva primera clave 4 Si la ocupació ocupación del nodo es inferior a m/2 y y el hermano a la izquierda o derecha tiene espacio suficiente, pasar las claves al hermano y eliminar el nodo completo. Actualizar el padre eliminado la clave correspondiente (para ello volver al paso 2) 5 Si la ocupació ocupación del nodo es inferior a m/2 y y los hermanos a izquierda o derecha no tienen espacio suficiente, redistribuir las claves con uno de los dos hermanos. Actualizar las claves de los niveles superiores para reflejar los cambios 14
Árboles B y B+
Ejemplo:
AbbBet01|AbbFer01|BeaCal01|BeaShe02
BeaShe02|BeaShe03|BeaTha01
AbbBet01|AbbCas01|AbbChi01
AbbFer01|AbbSar02
BeaCal01|BeaShe01
Borrar BeaTha01. BeaTha01. La clave se elimina trivialmente AbbBet01|AbbFer01|BeaCal01|BeaShe02
BeaShe02|BeaShe03
AbbBet01|AbbCas01|AbbChi01
AbbFer01|AbbSar02
BeaCal01|BeaShe01
15
Árboles B y B+
Borrar BeaShe03 . La ocupació ocupación del nodo cae por debajo del umbral. El hermano a la izquierda tiene espacio para albergar la clave restante (BeShe02) AbbBet01|AbbFer01|BeaCal01
AbbBet01|AbbCas01|AbbChi01
AbbFer01|AbbSar02
BeaCal01|BeaShe01|BeaShe02
Borrar AbbSar02 . Situació Situación similar a la anterior
AbbBet01|BeaCal01
AbbBet01|AbbCas01|AbbChi01|AbbFer01
BeaCal01|BeaShe01|BeaShe02
16
Árboles B y B+
Borrar BeaCal01. BeaCal01. Borrado trivial, aunque al tratarse de la primera clave, es necesario actualizar el padre AbbBet01|BeaShe01
AbbBet01|AbbCas01|AbbChi01|AbbFer01
BeaShe01|BeaShe02
Borrar BeaShe02 . El hermano no tiene sitio para albergar la clave restante. Redistribuir en su lugar y actualizar la primera clave en el padre AbbBet01|AbbFer01
AbbBet01|AbbCas01|AbbChi01
AbbFer01|BeaShe01
17
Árboles B y B+
La clase para un nodo de un á rbol rbol B
template class NodoArbolB { ClaveP claves[orden]; long int posiciones[orden]; unsigned ocupacion; bool hoja; public: NodoArbolB(); void insertar(ClaveP clave, unsigned long posicion); void eliminar(ClaveP clave); void dividir(NodoArbolB &nodo); void unir(NodoArbolB &nodo); void redistribuir(NodoArbo redistribuir(NodoArbolB lB &nodo); long int buscarIgual(ClaveP clave); long int buscarIgualMenor(Clav buscarIgualMenor(ClaveP eP clave); ClaveP primeraClave(); unsigned numClaves(); bool esHoja(); };
18
Árboles B y B+
La clase para el á rbol rbol B
#include #include using namespace std; template class ArbolB { Fichero > fDatos; public: ArbolB(string fDatos, bool crear = false); void insertar(ClaveP claveP, unsigned long pos); void borrar(ClaveP claveP); unsigned long buscar(ClaveP claveP); };
Esta clase únicamente resuelve un índice en forma de árbol B. Posteriormente es necesario integrarla en una clase similar a FicheroIndices (tema (tema anterior) con un fichero de datos 19
Árboles B y B+
Acceso secuencial indexado: Árboles B+ Los árboles B proporcionan una solución definitiva al problema de la indexación de un fichero para la búsqueda de un dato por clave Pero ¿Que ocurre si nuestra aplicación requiere un acceso secuencial a los registros siguiendo la ordenación dada por la clave? Ejemplo: obtenció obtención de listados ordenados
Hasta ahora tenemos dos posibilidades: posibilidades: Mantener ordenados fí físicamente los registros del fichero de datos. El recorrido del fichero es sencillo y eficiente, aunque el coste de mantener el fichero ordenado es altí altísimo
20
Árboles B y B+
Recorrer las hojas del árbol B de izquierda a derecha. Esto proporciona un listado de los registros ordenados por clave. Sin embargo implica un recorrido en inorden, leyendo todos los nodos del árbol B má más accesos adicionales a los registros del fichero de datos AbbChi01|BeaMyb01|BeaTha01|PriIwa01
PriIwa01|QueWea01|RoxLov01 AbbChi01|AbbFer01|BeaCal01
BeaMyb01|BeaShe01|BeaShe02
BeaTha01|BobLik01|EagHot01|FleSar01
Fichero de datos
21
Árboles B y B+
Ficheros de secuencias de bloques
La solución al problema es mantener ordenados físicamente los registros del fichero, pero sólo a nivel de bloque Cada bloque va a contener varios registros, y el fichero de datos va a estar constituido por una secuencia ordenada lógicamente de bloques AbbChi01|...$AbbFer01|...$BeaCal01|...$ BeaMyb01|...$BeaShe01|...$BeaShe02|...$ PriIwa01|...$QueWea01|...$RoxLov01|...$ BeaTha01|...$BobLik01|...$EagHot01| BeaTha01|...$BobLik01|...$EagHot01|...$FleSar01...$ ...$FleSar01...$
22
Árboles B y B+
Los bloques tienen las siguientes características: Son de tamañ tamaño fijo. El mejor rendimiento se consigue si su tamañ tamaño es igual al de un bloque del sistema de ficheros Un bloque puede estar parcialmente vací vacío, aunque su ocupació ocupación no puede ser menor del 50% Los registros dentro de cada bloque está están ordenados por la clave Cada bloque contiene un apuntador al siguiente bloque en la secuencia ordenada. La ordenació ordenación ló lógica no tiene que coincidir con la fí física
Mantener ordenado un bloque sí es eficiente puesto que se transfiere íntegramente a memoria para realizar una operación de inserción o borrado Si el tamaño del bloque es igual al bloque del sistema de ficheros, la transferencia requiere un único acceso
23
Árboles B y B+
Realizar un recorrido ordenado de los registros es sencillo y eficiente Basta con ir leyendo de forma ordenada cada bloque y procesar los registros en su interior, siguiendo tambié también su orden interno
La inserción de un nuevo registro en el fichero implica los siguientes pasos 1 Localizar el bloque al que pertenece (esto lo haremos utilizando un árbol B, como veremos má más adelante) 2 Pasar el bloque a memoria 3 Si el bloque tiene espacio para el nuevo registro, realizar su inserció inserción en la posició posición correspondiente. Salvar el bloque en el fichero y terminar 4 Si el bloque no tiene espacio, entonces es necesario crear un nuevo bloque, al final del fichero o en un hueco existente de un bloque borrado anterior. Insertar el nuevo bloque en la lista, a continuació continuación del bloque original 5 De forma similar a los árboles B, repartir los registros entre los dos bloques existentes e insertar el nuevo registro en el que corresponda. Salvar ambos bloques en el fichero 24
Árboles B y B+
Ejemplo: AbbChi01|...$AbbFer01|...$BeaCal01|...$ BeaMyb01|...$BeaShe01|...$BeaShe02|...$ PriIwa01|...$QueWea01|...$RoxLov01|...$ BeaTha01|...$BobLik01|...$EagHot01| BeaTha01|...$BobLik01|...$EagHot01|...$FleSar01...$ ...$FleSar01...$
Insertar BeaDer03 y y BasMan02 : AbbChi01|...$AbbFer01|...$BasMan02| AbbChi01|...$AbbFer01|...$BasMan02|...$BeaCal01|...$B ...$BeaCal01|...$BeaDer03|...$ eaDer03|...$ BeaMyb01|...$BeaShe01|...$BeaShe02|...$ PriIwa01|...$QueWea01|...$RoxLov01|...$ BeaTha01|...$BobLik01|...$EagHot01| BeaTha01|...$BobLik01|...$EagHot01|...$FleSar01...$ ...$FleSar01...$
Insertar BatCat01: BatCat01: AbbChi01|...$AbbFer01|...$BasMan02|...$ BeaMyb01|...$BeaShe01|...$BeaShe02|...$ PriIwa01|...$QueWea01|...$RoxLov01|...$ BeaTha01|...$BobLik01|...$EagHot01| BeaTha01|...$BobLik01|...$EagHot01|...$FleSar01...$ ...$FleSar01...$ BatCat01|...$BeaCal01|...$BeaDer03|...$
25
Árboles B y B+
El borrado es similar al borrado en un árbol B 1 Localizar el bloque donde está está situado el registro 2 Pasar el bloque a memoria 3 Eliminar el registro del bloque. Si la ocupació ocupación del bloque sigue siendo superior al 50% terminar 4 En caso contrario comprobar la ocupació ocupación de los bloques anterior y posterior 5 Si uno de los dos tiene espacio para albergar los registros del bloque actual, pasar éstos al bloque en cuestió cuestión, desconectar el bloque actual y marcar como borrado para ser aprovechado en inserciones posteriores 6 En caso contrario, escoger uno de los dos bloques y redistribuir los registros entre ambos bloques de forma equitativa
26
Árboles B y B+
Ejemplo: AbbChi01|...$AbbFer01|...$BeaCal01|...$ BeaMyb01|...$BeaShe01|...$BeaShe02|...$ PriIwa01|...$QueWea01|...$RoxLov01|...$ BeaTha01|...$BobLik01|...$EagHot01| BeaTha01|...$BobLik01|...$EagHot01|...$FleSar01...$ ...$FleSar01...$
Eliminar BeaCal01. BeaCal01. Los registros restantes se pasan al segundo bloque
AbbChi01|...$AbbFer01|...$BeaMyb01| AbbChi01|...$AbbFer01|...$BeaMyb01|...$BeaShe01|...$B ...$BeaShe01|...$BeaShe02|...$ eaShe02|...$ PriIwa01|...$QueWea01|...$RoxLov01|...$ BeaTha01|...$BobLik01|...$EagHot01| BeaTha01|...$BobLik01|...$EagHot01|...$FleSar01...$ ...$FleSar01...$
Eliminar QueWea01. QueWea01. De nuevo la ocupació ocupación del bloque cae por debajo del 50%. Los registros de los dos primeros bloques se redistribuyen
AbbChi01|...$AbbFer01|...$BeaMyb01| AbbChi01|...$AbbFer01|...$BeaMyb01|...$BeaShe01|...$B ...$BeaShe01|...$BeaShe02|...$ eaShe02|...$ FleSar01...|PriIwa01|...$RoxLov01|...$ BeaTha01|...$BobLik01|...$EagHot01|...$
27
Árboles B y B+
La representaci ó ón de un bloque en memoria
template class BloqueReg { ClaveP claves[tamBloq]; Registro registros[tamBloq]; unsigned ocupacion; unsigned bloqueSig; public: BloqueReg(); void insertar(ClaveP clave, Registro reg); void eliminar(ClaveP clave); Registro leer(ClaveP clave); unsigned leerBloqueSig(); void dividir(BloqueReg &bloque); void unir(BloqueReg &bloque); void redistribuir(BloqueRe redistribuir(BloqueReg g &bloque); ClaveP primeraClave(); unsigned numReg(); // Iteración por el bloque void iniciarIteracion(Clav iniciarIteracion(ClaveP eP clave); bool obtenerSiguiente(Clav obtenerSiguiente(ClaveP eP &clave, Registro ®); }; 28
Árboles B y B+
Fichero estructurado en bloques #include using namespace std; template class FicheroBloques { Fichero > f public: FicheroBloque(string fDatos); ~Fichero(); // Cierra el fichero void insertar(unsigned insertar(unsigned bloq, ClaveP ClaveP clave, clave, const Registro ®); ®); bool bloqueDividido(unsi bloqueDividido(unsigned gned &bNuevo); void eliminar(unsigned bloq, ClaveP claveP); bool bloqueUnido(unsigne bloqueUnido(unsigned d &bDest); bool bloqueRedistribuido bloqueRedistribuido(unsigned (unsigned &bloq1, unsigned &bloq2); void leer(unsigned bloq, ClaveP claveP, Registro ®); void actualizar(unsigned actualizar(unsigned bloq, ClaveP ClaveP claveP, const Registro Registro ®); ®); ClaveP primeraClave(unsigne primeraClave(unsigned d bloq); // Iteración por el fichero void iniciarIteracion(un iniciarIteracion(unsigned signed bloq, ClaveP clave); bool obtenerSiguiente(Cl obtenerSiguiente(ClaveP aveP &clave, Registro ®); }; 29
Árboles B y B+
Árboles B +
Denominamos árbol B+ a la estructura que combina un fichero de datos estructurado en una secuencia de bloques de registros con un árbol B para indexar dichos bloques Árbol B AbbChi01|BeaTha01
AbbChi01|BeaMyb01
AbbChi01...BeaCal01
BeaTha01|PriIwa01
BeaMyb01...BeaShe02
BeaTha01...FleSar01
PriIwa01...RoxLov01
Fichero de datos 30
Árboles B y B+
Un árbol B+ permite tanto accesos por clave (mediante el árbol B) como recorridos secuenciales a través de la secuencia de bloques Las hojas del árbol B contienen las claves iniciales de cada uno de los bloques, así como las direcciones de los mismos La inserción contempla los siguientes aspectos Localizar mediante al árbol B el bloque que le corresponde Insertar el registro en el bloque. Si el registro se situa en primera posició posición, entonces actualizar el índice en el árbol B Si no hay espacio en el bloque, entonces se crea un nuevo bloque. Esto implica insertar la primera clave del nuevo bloque en el árbol B
31
Árboles B y B+
El borrado sigue los siguientes pasos: Localizar el bloque al que pertenece el registro mediante el árbol B Eliminar el registro. Si ocupaba la primera posició posici ón, actualizar los índices correspondientes en el árbol B Si se produce la eliminació eliminación de un bloque, eliminar la entrada correspondiente en el árbol B Si se produce una redistribució redistribución de registros, actualizar los índices correspondientes en el árbol B
32
Árboles B y B+
La clase á rbol rbol B + #include using namespace std; template class ArbolBMas { FicheroBloques fDatos; ArbolB indice; public: ArbolBMas(string fDatos, bool crear = false); ~ArbolBMas(); void insertar(ClaveP claveP, Registro reg); void borrar(ClaveP claveP); Registro buscar(ClaveP claveP); // Iteración por el fichero void iniciarIteracion(Cl iniciarIteracion(ClaveP aveP claveP); bool obtenerSiguiente(Cl obtenerSiguiente(ClaveP aveP &claveP, Registro ®); };
33
