Cap. 17. B-Trees - Inicio

Capítulo 17.
1
B-Trees.
17.1 Definición de B-Trees de grado t.
Un árbol T es un B-Tree de grado t si:
a) Todas las hojas de T tienen igual profundidad.
b) Todos los nodos tienen a lo menos (t-1) claves almacenadas, excepto la raíz.
c) Todos los nodos tienen a lo más (2t-1) claves almacenadas.
d) La raíz tiene a lo menos una clave.
e) Un nodo con (2t-1) claves tiene (2t) hijos.
17.2. Cálculo de la altura de un B-Tree.
Si n 1 y t 2, un B-Tree con n claves tiene altura h acotada según:
n 1
log
2t( n 1) 1 h log
t( )
2
Demostración.
En el caso de que todos los nodos, incluida la raíz tengan el menor número de nodos, se tiene
2
que la raíz tiene dos hijos; un nodo con (t-1) claves tiene t hijos y t nietos. La Figura 17.1,
ilustra el crecimiento del B-Tree con t=4. El menor número de claves que puede tener la raíz es
una.
1
2
3
Figura 17.1 B-tree con (t-1) claves en un nodo. Cada nodo tiene t hijos.
La siguiente serie geométrica, genera el número de nodos en uno de los subárboles de la raíz. En
2
el primer nivel hay un nodo, en el segundo se tienen t nodos, y en el tercero t ; por inducción se
h 1
tendrán t en el nivel h.
k h h
k 1 2 1 1
1 ... h t
t t t t
t 1
k 1
Profesor Leopoldo Silva Bijit 20-01-2010

2 Estructuras de Datos y Algoritmos
Como la raíz tiene una clave y dos descendientes; y cada nodo tiene a lo menos (t-1) claves, el
número total n de claves almacenadas en los nodos, incluida la raíz, en un B-Tree de altura h
será:
t 1
n t t t t
t 1
k h h
1
1 2( 1) k
1 2( 1)( ) 2 h
1
k 1
Sacando logaritmo en base t, se obtiene:
n 1
h log
t
( )
2
Para acotar h por abajo:
Si los nodos tienen a lo más (2t-1) claves, tendrán 2t hijos.
En la raíz se tendrán (2t-1) claves, y ésta tendrá 2t hijos, cada uno con (2t-1) claves. Se tienen
2
(2 t ) nodos nietos, en el nivel 2 del B-Tree. Finalmente en el nivel h, se tendrán: (2 t ) h nodos.
Figura 17.2 B-tree con máximo número de claves en cada nodo, con t=4.
La suma total de nodos del B-Tree, en este caso, puede expresarse según:
k h 1
k 1 2
h
(2 t) 1 2 t (2 t) ... (2 t)
k 1
h 1
(2 t) 1
2t
1
Entonces el número total de claves almacenadas en un B-Tree de altura h, debe ser menor que:
k h 1
h 1
k 1 (2 t) 1 h 1
n (2t 1) (2 t) (2t 1)( ) (2 t) 1
2t
1
k 1
Sacando logaritmo en base 2t, se obtiene la cota inferior de h.
log
2t ( n 1) 1 h
La Figura 17.3 muestra el acotamiento de la altura de un B-Tree de grado t=4.
Profesor Leopoldo Silva Bijit 20-01-2010

B-Trees 3
B-Tree
Binario balanceado
Figura 17.3 Altura de B-tree con t=4.
El número de total de claves en un B-Tree de grado t, con altura h está en el siguiente intervalo.
1
(2 ) h
h
t 1 n 2t
1
Figura 17.4 Claves máximas y mínimas almacenadas en B-tree con t=4.
17.3. Requerimientos de espacio y relaciones de ordenamiento de las claves.
Los requerimientos de espacio para un nodo dependen de t. Para t=2, se requiere un
nodo que pueda almacenar 3 claves y que tenga espacio para 4 punteros. Si t=4, se
requiere nodo con espacio para 7 claves y espacio para 8 punteros.
El esquema de la Figura 17.5, muestra que si se tienen 3 claves, el nodo debe contener el
número de claves más uno, de tal forma que puedan definirse donde se almacenaran las claves
menores y mayores que cada una de las claves del nodo.
Profesor Leopoldo Silva Bijit 20-01-2010

4 Estructuras de Datos y Algoritmos
a 0 a 1 a 2
p 0
p 1
p 2
p 3
b 0 b 1 b 2 c 0 c 1 c 2 d 0 d 1 d 2 e 0 e 1 e 2
Figura 17.5 Esquema de B-tree con t=2.
El ordenamiento de las claves, en los nodos, en forma similar a un árbol binario de búsqueda,
cumple las relaciones, para el caso de la Figura 17.5:
e2 e1 e0 a2 d2 d1 d0 a1 c2 c1 c0 a0 b2 b1 b
0
Se tiene que p
0
apunta a descendientes con valores de claves menores que a 0
; y p
1
apunta a
descendientes con valores de claves menores que a
1
, y mayores que a
0
.
El requerimiento del mínimo número de claves almacenadas en un nodo, se aclarará cuando se
analicen las operaciones de inserción y descarte.
17.4. Complejidad en la búsqueda.
Para buscar una clave en un B-Tree de grado t, el peor caso es cuando se tienen (t-1) claves en
cada nodo, ya que en este caso se tiene la mayor altura. Si buscamos la clave en un nodo,
mediante una búsqueda binaria, aprovechando que el arreglo de claves está ordenado, y luego
repetimos esta búsqueda en cada uno de los nodos de la ruta de descenso, que es el peor caso en
búsqueda, tendremos:
T( n) h TBB( t 1)
Una búsqueda binaria entre n elementos tiene una complejidad:
T ( n) (log ( n ) 1)
BB
2
La altura en peor caso es:
h
n 1
log
t
( )
2
Reemplazando, se obtiene:
n 1
T( n) log
t
( ) (log
2( t 1) 1)
2
Puede efectuarse la siguiente aproximación, para t mayor que 100:
log ( t 1) 1 log ( t )
2 2
Profesor Leopoldo Silva Bijit 20-01-2010

B-Trees 5
Y cambiando el logaritmo de base t a base 2, se tiene:
n 1
log
2( )
n 1
log ( ) 2
t
2 log ( t)
Lo que finalmente permite obtener la complejidad de buscar una clave en un B-Tree de grado t:
n 1
T( n) log
2( ) (log( n ))
2
Que muestra que la búsqueda de una clave, en peor caso, en un B-Tree, tiene complejidad
logarítmica.
17.5 Análisis de la operación inserción.
17.5.1 Ejemplo de inserción en un 2-4-Tree.
Asumiremos un nodo con 4 claves máximo y 2 claves mínimo. Insertaremos las claves en forma
ascendente a partir del número 1, lo cual es el peor caso para un árbol binario de búsqueda. Esta
estructura es una variación del B-Tree de grado t; en el caso del ejemplo se denomina 2-4-Tree.
Luego de crear el nodo raíz, se pueden agregar 4 claves. Cuando se agrega el número 5, se
produce un rebalse del nodo raíz; y es preciso dividir las claves del nodo raíz en dos nodos
descendientes, de esta manera el B-Tree crece un nivel. La altura crece por rebalse de las hojas.
Se activan dos punteros en el nodo raíz, como se muestra al centro de la Figura 17.6.
Como tenemos 5 claves, podemos dejar los nodos descendientes con dos claves cada una, y de
este modo quedan con el mínimo posible; y además mover la clave 3, del nodo que rebalsó, a la
raíz. Quedando ésta con una sola clave, cumpliendo las propiedades de un B-tree. Luego se
procede al ingreso de las claves 6 y 7, completando las claves de ese nodo, lo cual se muestra en
la Figura 17.6 a la derecha.
2
Figura 17.6. B-Tree después de ingresar la clave 4, 5 y 7.
Las claves siempre se insertan en las hojas, para cumplir la propiedad de que un B-Tree tiene
hojas de igual profundidad.
Luego, al introducir la clave 8, se rebalsa el nodo, y se lo divide en dos, pasando una clave a la
raíz, ahora ésta tiene tres punteros activos. Luego de ingresadas las claves 9 y 10, se completan
las claves de ese nodo, lo cual se ilustra en la Figura 17.7, a la derecha.
Profesor Leopoldo Silva Bijit 20-01-2010

6 Estructuras de Datos y Algoritmos
Figura 17.7. B-Tree después de ingresar la clave 8, y 10.
Luego de ingresar la clave 11, se activa un nuevo puntero en la raíz, debido a la división de un
nodo en dos, el ascenso del 9 y la redistribución de claves. La Figura 17.8, a la derecha muestra
el nodo con todas sus claves, luego de ingresadas las claves 12 y 13.
Figura 17.8. B-Tree después de ingresar la clave 11, y 13.
Al insertar la clave 14, se activa el último puntero de la raíz, y además ésta queda con todas sus
claves ocupadas.
Figura 17.9. B-Tree después de ingresar la clave 14.
Se pueden ingresar las claves 15 y 16, completando las claves del nodo ubicado más a la
derecha, lo que se muestra en la Figura 17.10.
Figura 17.10 B-Tree después de ingresar la clave 16.
Al introducir la clave 17, se divide el nodo ascendiendo la clave 15, pero ésta no puede ser
almacenada en la raíz, y se procede a la división del nodo raíz, ascendiendo la clave 9, que se
deposita en una nueva raíz; de este modo se vuelve a incrementar la altura del B-Tree.
Figura 17.11 B-Tree después de ingresar la clave 17.
Profesor Leopoldo Silva Bijit 20-01-2010

B-Trees 7
La Figura 17.12, muestra que después de ingresada la clave 25, se han agregado dos nodos al
subárbol izquierdo, quedando completos los nodos de más a la derecha del segundo y tercer
nivel.
Figura 17.12 B-Tree después de ingresar la clave 25.
Después de ingresar la clave 26, asciende la clave 24, y posteriormente la clave 18.
Figura 17.13 B-Tree después de ingresar la clave 26.
Cada vez que asciende una clave, se activan nuevos puntero, y se dividen los nodos.
17.5.2 Análisis de inserción en un B-Tree de grado t.
Otra forma de diseñar la operación es insertar siempre la nueva clave en una hoja que no esté
completa; para lograr esto a medida que se desciende desde la raíz, buscando la posición para
insertar, si se encuentra un nodo completo, se procede a la división de éste, repartiendo
equitativamente las claves; y repitiendo este procedimiento hasta insertar finalmente la clave en
una hoja que no está completa.
Es importante destacar que antes de invocar a insertar, debe asegurarse que la clave no esté
presente, ya que en el descenso se modifica la estructura del B-Tree, y es posible que la hoja
donde debería insertarse la clave quede con menos de (t-1) claves, violando las propiedades de
un B-Tree.
a) Árbol vacío.
Se crea un nodo vacío y se le agrega el valor en la primera posición, el nodo se marca como
hoja.
b) Inserción en hoja con menos de (2t-1) claves.
Profesor Leopoldo Silva Bijit 20-01-2010

8 Estructuras de Datos y Algoritmos
p
i n-1
a 0 … a i … a n-1
Figura 17.14 Inserción en hoja que no está llena.
Se ubica el índice i, cuya clave ai
es menor que el valor v que debe insertarse. Se desplazan las
claves, a partir de la clave a
i 1
, en una posición hacia la derecha. Se inserta la clave v, a la
derecha de la clave a
i
. Se aumenta el número de claves activas en p.
p
i
n
a 0 … a i v a i+1 … a n-1
Figura 17.15 Después de insertar v en hoja que no estaba llena.
Buscar el índice i, tal que ai
v, mediante búsqueda binaria tiene un costo de O(log(2t 1)) .
En el peor caso, cuando i 1, es decir cuando a 0
v, hay que desplazar (2t 2) claves y
además copiar la clave v, entonces el costo de esta operación es:
c) Inserción en nodo interno.
O(log(2t 1)) O(2t 2) O(1) O( t )
Se ubica la clave ai
que es menor que el valor v que debe insertarse. Sea p
i 1
la dirección del
nodo donde debe insertarse la clave v, que puede denominarse ancestro de v.
c1) Si ancestro no está completo
Si el nodo apuntado por p
i 1
no está completo, se procede a insertar recursivamente v en el
nodo apuntado por p
i 1
, descendiendo un nivel en el B-Tree. Esta operación tiene el costo de la
búsqueda de la clave menor que v, que es O(log(2t 2)) .
c2) Si el ancestro de v, está completo.
Para mantener la condición de descender a un nodo que no está completo, debe partirse el nodo
apuntado por pi
1
en dos.
Profesor Leopoldo Silva Bijit 20-01-2010

B-Trees 9
p
i
a 0 … a i a i+1 … a na-1
p i+1
c 0 … c t-2 c t-1 c t … c 2t-2
Figura 17.16 Descender a un nodo que está completo.
La clave central c
t 1
se inserta a la derecha de a
i
, previo a esto deben desplazarse una posición
a la derecha, las claves y los punteros desde ai
1
hasta el final, incrementando en uno el número
de claves activas en nodo p. Esto es posible siempre que p apunte a un nodo que no está
completo. Se crea un nuevo nodo, que se muestra como p
i 2
en la Figura 17.17, y se copian las
( t 1) claves mayores del nodo p
i 1
en las primeras posiciones del nuevo nodo. Además se
disminuye a ( t 1) el número de claves activas de p
i 1
. Si el ancestro de v es una hoja, también
será hoja el nuevo nodo; y si el ancestro de v es un nodo interno, el nuevo nodo también debe
ser nodo interno. En este último caso es preciso copiar también los punteros a descendientes en
las primeras posiciones del nuevo nodo.
p
i
a 0 … a i c t-1 a i+1 … a na-1
p i+1
p i+2
c 0 … c t-2
c t … c 2t-2
Figura 17.17 Después de partir ancestro de v.
Se continua invocando recursivamente a insertar valor v en el nodo p
i 1
que no está lleno si se
tiene que: ai
v c
t 1; y si se tiene que: ai
1
v c
t 1, el descenso debe ser insertar clave v en
nodo apuntado por p
i 2
. Pero ahora ambos hijos de p, son nodos que no están completos.
El costo de la operación debe considerar la búsqueda del puntero p
i 1
, de costo
O(log(2t 2)) ; debe considerar el desplazamiento de (2t-2) claves en nodo p, además debe
copiar (t-1) claves en p
i 2
, y si este nodo no es hoja debe copiar adicionalmente t punteros;
finalmente tiene que copiar una clave y un puntero en p. Entonces esta operación tiene un costo:
O(log(2t 2)) O(2t 2) O( t 1) O( t) O(2) O( t )
Profesor Leopoldo Silva Bijit 20-01-2010

10 Estructuras de Datos y Algoritmos
c3) Si p es la raíz y está completa.
Un caso particular es si el nodo p es la raíz y si está completa. Demás esta decir que v no puede
estar en el nodo raíz, ya que no se aceptan claves duplicadas en un B-Tree.
raíz
c 0 … c t-2 c t-1 c t … c 2t-2
p
Figura 17.18 Inserción en raíz completa.
En este caso se crea un nuevo nodo raíz, y en la primera clave se coloca la clave central de p. Se
crea un nuevo nodo en el cual se colocan las (t-1) claves mayores de p. Se actualiza la raíz, y se
procede a insertar v, en la nueva raíz, pero ahora ésta no está completa. Esto da inicio al proceso
de insertar la clave en un nodo ( p
0
o p
1
) que no esté completo.
raíz
0
c t-1
…
p
p 0
p 1
c 0 … c t-2
c t … c 2t-2
17.5.3 Costo de la inserción.
Figura 17.19 Después de intentar insertar en raíz completa.
Si se asume que el costo de insertar una clave en un nodo que no esté lleno, en el peor caso es
de costo Ot (); y como esto se repetirá h veces, uno por cada descenso desde la raíz hasta la
hoja en que se insertará efectivamente la clave. Siendo h la altura del B-Tree, la complejidad de
la operación insertar, será O( th ).
n 1
Antes se demostró que: O( h) O(log t( )) O(log t( n ))
2
Entonces finalmente, la operación insertar tiene complejidad: O( t log
t
( n )) , siendo n el número
de claves almacenadas en el B-Tree.
17.6 Análisis de la operación descartar.
En un multiárbol, se puede borrar la clave en cualquier nodo; sin embargo, si el nodo en el cual
se encuentra la clave que será descartada tenía el número mínimo de claves, dejará de cumplirse
Profesor Leopoldo Silva Bijit 20-01-2010

B-Trees 11
una de las propiedades del B-Tree, y será preciso corregir la estructura. La estrategia es
descartar la clave en una hoja que tenga más del número mínimo de claves.
La operación como se verá a continuación es bastante más compleja que la inserción, sin
embargo como en un B-Tree, el mayor número de claves se encuentran en las hojas, es más alta
la probabilidad de descartar una clave que se encuentre en una hoja.
17.6.1. Descarte en hoja con más claves que el mínimo número.
Veremos primero el caso de descartar la clave en una hoja, y siempre que ésta tenga más del
número mínimo de claves almacenadas.
p
a 0 a 1 a 2 … a n-1
Figura 17.20. Hoja con más de (t-1) claves.
En este caso sólo es preciso desplazar las claves en una posición hacia la izquierda, a partir de la
siguiente a la descartada, y disminuir en uno el número de claves activas en el nodo. No es
preciso copiar los punteros, pues éstos almacenan valores iguales a nulos.
Un caso particular es si el nodo es la raíz y tiene un solo elemento; en este caso el B-Tree queda
vacío.
Buscar la clave dentro del nodo, en el peor caso, es de complejidad O(2t-1) si se emplea
búsqueda secuencial y O(log(2t-1)) si se emplea búsqueda binaria. Se requiera además mover,
en el peor caso, (2t-2) claves lo cual implica complejidad O(2t-2).
Si se emplea búsqueda binaria, esta operación tiene un costo:
O(log(2t 1)) O(2t 2) O( t )
Para lograr que el nodo que contenga la clave que será descartada, tenga más del número
mínimo de elementos, puede procederse al descenso desde la raíz hasta la hoja que contenga el
nodo con la clave buscada, realizando modificaciones para asegurar que siempre se producirá un
descenso a un nodo que tenga más de (t-1) claves, cuya solución se acaba de describir.
17.6.2. Descarte en nodo p que no es hoja y que contiene la clave v.
Se asume que nodo p, tiene más de ( t 1) claves, y que i es el índice de la clave v.
Profesor Leopoldo Silva Bijit 20-01-2010

12 Estructuras de Datos y Algoritmos
p
i
a 0 … v a i+1 … a na-1
p i p i+1
b 0 … b i … b nb-1 c 0 … c i … c nc-1
Figura 17.21. Nodo interno con más de (t-1) claves, y clave con hijo izquierdo y derecho.
Hijo izquierdo con más claves que la mínima.
Si nb
( t 1) se copia la clave b
nb 1
, que es el mayor descendiente del subárbol izquierdo, en
lugar de v; y se continua recursivamente descartando la clave bnb
1
en el nodo apuntado por p
i
.
p
i
a 0 … a i+1 … a na-1
b nb-1
p i
b 0 … b i … b nb-1
Figura 17.21a. Se recurre a borrar el predecesor de v.
Debe notarse que en este caso, se desciende un nivel, y se está borrando una clave en un nodo
que tiene más de (t-1) claves. Esta operación incurre en el costo de encontrar la clave, y luego
efectuar una copia; entonces se tiene, para búsqueda binaria:
Hijo derecho con más claves que la mínima.
O(log(2t 1)) O(1) O(log( t )) .
Si lo anterior no se cumple, pero nc
( t 1) , se copia la clave c
0
, que es el menor descendiente
del subárbol derecho, en el lugar de v; y se continua descartado la clave c
0
en el nodo apuntado
por p
i 1
. Debe notarse que en este caso se está borrando una clave en un nodo que tiene más de
(t-1) claves. Con igual costo que la anterior.
Profesor Leopoldo Silva Bijit 20-01-2010

B-Trees 13
p
i
a 0 … a i+1 … a na-1
c 0
p i+1
c 0 … c i … c nc-1
Figura 17.21b. Se recurre a borrar el sucesor de v.
Ambos hijos con número de claves mínimas.
Si no se cumplen las dos condiciones anteriores, y el nodo p no es la raíz, se asume que debe
tener más de (t-1) claves, en este caso se agrega al nodo apuntado por p , la clave v, y las claves
del hermano derecho, el nodo apuntado por p
i 1
, quedando éste completo con (2t-1) claves. Se
libera el espacio del nodo apuntado por p
i 1
, y se procede a descartar recursivamente v, en el
nodo apuntado por p
i
.
p
i
na-2
a 0 … a i+1 … a na-1
i
nb
p i
2t-2
p i+1
b 0 … v … c nc-1 c 0 … c i … c nc-1
Figura 17.22. Mezcla del hijo izquierdo y derecho.
Esto implica desplazar las claves y los punteros en el nodo apuntado por p. Además deben
copiarse las nc claves en p , a continuación de v; y si p no es hoja, los punteros del nodo
i
pi
1
deben también copiarse al nodo p
i
.
Si consideramos que el costo de encontrar la clave es O(log(2t 1)) , en el peor caso; y que
además deben moverse (2t 2) claves y (2t
1) punteros en p; y que también deben moverse t
claves, ( t 1) desde p
i 1
y la clave v desde p; y finalmente t punteros desde p
i 1
, se tiene un
costo de: O(log(2t 1)) O(2t 2) O(2t 1) O( t) O( t ) .
Nodo raíz con claves mínimas.
Si el nodo p es la raíz, puede quedar luego de la operación con menos de (t-1) claves. Esto se
ilustra en la Figura 17.23, con t=3, cuando se desea descartar la clave 15. En este caso la clave
i
Profesor Leopoldo Silva Bijit 20-01-2010

14 Estructuras de Datos y Algoritmos
está en el nodo apuntado por p, y luego de la operación, propuesta antes, se obtiene la Figura
17.24. En la cual se cumple que luego de la operación descrita antes, el nodo apuntado por p
i
tiene (2t-1) claves.
p
1
10 15
p i p i+1
4 6 18 20
Figura 17.23. Hijos con claves mínimas, raíz con dos elementos.
p
0
10
t-1 p i p i+1
4 6 15 18 20 18 20
Nodo raíz con una sola clave.
Figura 17.24. Fusión de hijos.
Si el nodo p es la raíz, y tiene una sola clave, esto se muestra en la Figura 17.25, y se desea
borrar la clave 10, se procede de igual forma, sin embargo es preciso cambiar la raíz, y liberar
adicionalmente el nodo p. Esta es la única forma en que el B-Tree disminuye su altura.
raíz
p 0
10
p i p i+1
4 8 14 18
Figura 17.25. Hijos con claves mínimas, raíz con un elemento.
Profesor Leopoldo Silva Bijit 20-01-2010

B-Trees 15
raíz
p i
p
t-1
0
10
p i+1
4 8 10 14 18 14 18
Figura 17.26. Nueva raíz, y fusión de hijos.
17.6.3. Descarte en nodo p que no es hoja y que no contiene la clave v.
Si se ubica, con la posición i, la clave ai
que es menor que el valor v buscado para descartar, se
tendrá que pi
1
apunta al nodo que contiene el valor, o a alguno de sus descendientes, que
contiene efectivamente el valor v.
p
i
a 0 … a i a i+1 … a na-1
p i p i+1
p i+2
b 0 … b i … b nb-1
c 0 … c i … c nc-1
d 0 … d i … d nd-1
Figura 17.27. Descarte en nodo interno que no contiene la clave buscada.
Se asume que p tiene más de ( t 1) claves, excepto que sea la raíz. Y lo que desea asegurar es
que se descenderá a un nodo con más de ( t 1) claves.
Ancestro de v, tiene más de (t-1) claves.
Si pi
1
tiene más de ( t 1) claves, se procede a descartar recursivamente v, en el nodo apuntado
por p
i 1
, descendiendo un nivel.
Esta operación tiene el costo de encontrar la clave: O(log(2t 1)) .
Si pi
1
tiene (t-1) claves, pueden suceder tres casos:
Hermano izquierdo de ancestro de v, tiene más de (t-1) claves.
Es decir: nb
t 1. Se desplazan las claves y punteros de pi
1
en una posición hacia la derecha;
los punteros sólo si pi
1
no es hoja,. Luego se mueve a
i
al inicio de p
i 1
, el lugar que antes
ocupaba c
0
, a continuación se toma b
nb 1
y se lo coloca en el lugar que ocupaba a
i
.
Profesor Leopoldo Silva Bijit 20-01-2010

16 Estructuras de Datos y Algoritmos
Finalmente, para mantener la estructura del B-Tree, se copia el puntero que apunta a claves
mayores que b
nb 1
en la posición inicial de p
i 1
; es decir apuntando al nodo con claves menores
que a
i
. Se disminuye en uno el número de claves activas en p
i
. Luego se procede a descartar v
en el nodo apuntado por p
i 1
, que ahora es seguro que tiene más de ( t 1) claves.
Debe notarse que no hay hermano izquierdo de p
i 1
, si v a
0
.
p
i
a 0 … a i+1 … a na-1
b nb-1
p i p i+1
p i+2
b 0 … b i … b nb-2
a i c 0 … … c nc-1
d 0 … d i … d nd-1
Figura 17.28. Préstamo del hermano izquierdo.
Si consideramos que el costo de encontrar la clave es O(log(2t 1)) , en el peor caso; y que
además deben moverse ( t 1) claves y t punteros en p
i 1
; y que también deben efectuarse dos
copias de claves y una de puntero, se tiene un costo de:
O(log(2t 1)) O( t 1) O( t) O(3) O( t )
Esta operación puede aplicarse si el nodo p es la raíz.
Hermano derecho de ancestro de v, tiene más de (t-1) claves.
Es decir: nd
t 1. Se agrega al final de pi
1
la clave ai
1
y el puntero que apunta al nodo con
claves menores que d
0
, se coloca apuntado a nodos con claves mayores que a
i 1
; y se
incrementa en uno las claves activas de p
i 1
, quedando de este modo el ancestro de v, con más
de ( t 1) claves. Luego d
0
se coloca en el lugar que antes ocupaba a
i 1
. Se desplazan en una
posición a la izquierda las claves del nodo p
i 2
; y si ese nodo no es hoja también se desplazan
los punteros; finalmente se disminuye en uno las claves activas de p
i 2
. Luego se procede a
descartar v en el nodo apuntado por p
i 1
, que ahora tiene más de ( t 1) claves, descendiendo
un nivel.
Debe notarse que no hay hermano derecho de p
i 1
, si v a
na 1.
El costo es similar al caso anterior.
Profesor Leopoldo Silva Bijit 20-01-2010

B-Trees 17
p
i
b 0 … b i … b nb-1
a 0 … … a na-1
a i
p i p i+1
1
d 0
p i+2
c 0 … … c nc-1 a i+1
d 1 … d i … d nd-2
Figura 17.29. Préstamo del hermano derecho.
Esta operación puede aplicarse si el nodo p es la raíz, sin que ésta cambie.
Hermanos de ancestro de v, tienen (t-1) claves.
Al menos uno de los hermanos del ancestro de v debe existir, ya que p no contiene la clave con
valor v.
Si existe el hermano izquierdo
Se baja la clave a
i
, al final del nodo p i
, y se colocan las claves del ancestro de v a continuación;
y si éste no es hoja se copian también los punteros. Quedando de este modo el nodo p
i
con
(2t 1) claves activas. A partir de ai
1
se desplazan hacia la izquierda las claves y punteros en p,
disminuyendo en uno el número de claves activas. Se libera el espacio apuntado por p
i 1
. Se
continua descartando recursivamente v en el nodo apuntado por p
i
.
p
i
a 0 … a i+1 … a na-1
a i+2
d 0 … d nd-1
p i p i+1
p i+2
b 0
… b nb-1 a i c 0
..
c nc-1
c 0 … … c nc-1
d i
…
Figura 17.30. Fusión del ancestro con el hermano izquierdo.
Si consideramos que el costo de encontrar la clave es O(log(2t 1)) , en el peor caso; y que
además deben copiarse t claves y ( t 1) punteros en p i
; y que también deben efectuarse
( t 2) movimientos de clave y ( t 1) de punteros en nodo p, se tiene un costo de:
O(log(2t 1)) O( t) O( t 1) O( t 2) O( t 1) O( t )
Profesor Leopoldo Silva Bijit 20-01-2010

18 Estructuras de Datos y Algoritmos
Si no existe el hermano izquierdo.
Se baja clave a
i 1
, al final del nodo p
i 1
, a continuación se copian las claves de p
i 2
, y los
punteros si éste no es hoja. El nodo ancestro de v, queda con (2t 1) claves activas. A partir de
ai
2
se desplazan las claves y punteros en p, disminuyendo en uno el número de claves activas.
Se libera el espacio apuntado por p
i 2
. Se continua descartando v en el nodo apuntado por p
i 1
.
De similar costo a la anterior.
p
i
a 0 … a i … a na-1
a i+2
d 0 … d nd-1
p i+1
p i+2
c 0
… c nc-1 a i+1 d 0 .. d nd-1
d i
…
Figura 17.31. Fusión del ancestro con el hermano derecho.
Si el nodo p es la raíz, y tiene una sola clave, debe cambiarse la raíz al nodo que queda con
(2t 1) claves, y liberar además el antiguo nodo raíz.
17.6.4. Complejidad de la operación descarte.
Si se asume que el costo de descartar una clave en un nodo con al menos t elementos, en el peor
caso es de costo Ot (); y como esto se repetirá h veces, uno por cada descenso desde la raíz
hasta la hoja en que se descarta efectivamente una clave. Siendo h la altura del B-Tree, la
complejidad de la operación descartar, será O( th ).
n 1
Antes se demostró que: O( h) O(log t( )) O(log t( n ))
2
Entonces finalmente, la operación descartar tiene complejidad: O( t log
t
( n )) , siendo n el
número de claves almacenadas en el B-Tree.
17.7. Árboles coloreados.
Corresponden a un B-Tree de grado 2. Con un máximo de tres claves en un nodo, y un mínimo
de una clave en cada nodo.
Para convertir un árbol coloreado en un B-Tree se emplean las siguientes reglas:
a) Si el nodo contiene 3 claves, la central es negra, la primera y última son rojas.
b) Si el nodo contiene una clave, ésta es negra.
c) Si el nodo contiene dos claves, puede interpretarse de dos formas: Una es que la primera
clave es negra con hijo derecho rojo con la segunda clave; la otra es que la segunda clave es
negra con hijo rojo izquierdo con la primera clave.
Profesor Leopoldo Silva Bijit 20-01-2010

B-Trees 19
Una buena interpretación de los nodos rojos en un árbol coloreado, es dibujarlos en un nivel
horizontal, de este modo se refleja que no alteran las alturas negras de los nodos. Esto se
muestra en la Figura 17.33, para el árbol coloreado de la Figura 17.32.
9
4
15
2
5
12
20
7
Figura 17.32. Árbol binario coloreado.
En la representación con rojos en nivel horizontal, debe cuidarse que cada nodo tenga dos hijos,
para que el árbol sea binario. En el par 4-9, el primero se considera rojo; y en el par 5-7 el
segundo se considera rojo. La representación muestra que todas las hojas están en el mismo
nivel.
4
9
2
5
7
12 15
20
Figura 17.33. Coloreado con rojos horizontales.
Luego los nodos que están unidos por horizontales se consideran pertenecientes a un nodo de un
B-tree de grado dos, lo cual se muestra en la Figura 17.34.
4 9
p 0
p 1
p 2
2 5 7 12 15 20
Figura 17.34. B-tree de grado dos, equivalente del coloreado de la Figura 17.32.
Con esta interpretación pueden diseñarse las operaciones de inserción y descarte en árboles
coloreados, agrupando las claves que pertenezcan a un nodo de un B-Tree y realizando las
operaciones de mezcla y separación que se realizan en esta estructura, pero es preferible
especializar las operaciones, debido a que la estructura interna de un nodo de un árbol coloreado
es bastante más simple que la de un B-Tree.
Profesor Leopoldo Silva Bijit 20-01-2010

20 Estructuras de Datos y Algoritmos
17.8. Estructura de datos y funciones básicas.
17.8.1. Estructura de datos.
#define N 5 //2t-1 . t es el grado del B-tree
#define eshoja 1
#define esnodointerno 0
typedef struct nn
{
int clave[N];
struct nn *pn[N+1];
int act;
int hoja;
} nodo, *pnodo;
//con N claves en el Nodo
//número de claves activas en el nodo
// 1 es hoja; 0 en nodo interno
17.8.2. Creación de un nodo.
pnodo CreaNodo()
{ int i;
pnodo p=malloc(sizeof(nodo));
if (p!=NULL)
{ p->act=0;p->hoja=esnodointerno;
for(i=0;ipn[i]=NULL;
for(i=0;iclave[i]=0;
}
return(p);
}
17.8.4. Mostrar nodo y el B-Tree en niveles.
void PrtNodo(pnodo p)
{ int i;
if(p->act==0) printf("Nodo vacío\n");
else for(i=0; iact;i++) printf("%d ", p->clave[i]);
//putchar('\n');
}
void PrtBtree(pnodo p, int level)
{ int i;
if (p!=NULL)
{ for(i=1;ipn[0],level+1);
for(i=1;iact+1;i++) PrtBtree(p->pn[i],level+1);
}
}
Profesor Leopoldo Silva Bijit 20-01-2010

B-Trees 21
17.8.5. Búsqueda de un valor.
En casos prácticos el número de claves en un nodo es elevado, por lo que suele emplearse
búsqueda binaria.
int search(pnodo p, int valor)
{ int i,l,r;
while (p!=NULL)
{
l=0; r=p->act-1;
while (r>=l) //búsqueda binaria
{ i=(l+r)/2;
if (valorclave[i]) r=i-1;
if (valor>= p->clave[i]) l=i+1;
}
/* Si (valor < p->clave[0]) r=-1, l=0, (l-r)=1
Si (valor > p->clave[p->act-1]) r=p->act-1, l=p->act, (l-r)=1
Si Si (valor == p->clave[i]) r=i-1, l=i+1, (l-r)=2
*/
r++;
/* Lo encontró en posición r. ( l-r=1 => l+1=r => l>r )
Si no lo encontró: r=0 si (valor < p->clave[0])
r=p->act si (valor > p->clave[p->act-1])
*/
if(l>r) return(1); //lo encontró en posición r del arreglo.
else p=p->pn[r]; //busca en descendiente
}
return(0);//no lo encontró
}
17.8.6. Partir un nodo.
//en la posición i-esima de x ingresa la clave central de y.
//Pega el nuevo nodo z, en la posición (i+1) de x.
void split(pnodo x, int i, pnodo y)
{ int j;
pnodo z = CreaNodo();
if (z==NULL){printf("Error creación de nodo. Split"); exit(1);}
z->hoja=y->hoja; z->act=N/2; //z es hermana de y. Y se le copian los (t-1) superiores de y.
for(j=0;jclave[j]=y->clave[j+N/2+1];//copia claves en z
if(y->hoja ==esnodointerno) //si no es hoja
for(j=0;jpn[j]=y->pn[j+(N/2)+1];//copia punteros en z
y->act=N/2; //se desactivan las claves de la mitad superior de y
for(j=x->act+1;j>i ;j--) x->pn[j]=x->pn[j-1];//desplaza punteros en x
x->pn[i+1]=z;
Profesor Leopoldo Silva Bijit 20-01-2010

22 Estructuras de Datos y Algoritmos
for(j=x->act;j>i ;j--) x->clave[j]=x->clave[j-1];//desplaza claves en x
x->clave[i]=y->clave[N/2]; //asciende clave central del lleno
x->act++;
}
17.8.7. Inserción en nodo que no está lleno.
void insertenolleno(pnodo x,int valor)
{ int i;
if (x->hoja==eshoja)
{ for(i=x->act-1;i>=0 && valor < x->clave[i];i--)
x->clave[i+1]=x->clave[i];//crea un espacio
//i apunta a clave menor que el valor
x->clave[i+1]=valor;x->act++; //solo se inserta en hojas
}
else
{ for(i=x->act-1;i>=0 && valorclave[i];i--); //búsqueda secuencial
i++; //pn[i] apunta a la hoja donde debe insertarse. Ahora i es mayor o igual que cero
if(x->pn[i]->act==N)
{
split(x,i,x->pn[i]);
if(valor> x->clave[i])i++; //fija puntero en el descenso.
}
insertenolleno(x->pn[i],valor); //recursiva por el fondo
}
}
17.9. Inserción.
//Debe buscarse antes de insertar. Si la clave ya estaba, cambia B-Tree.
void inserte(pnodo *pbt, int valor)
{ pnodo p=*pbt,s;
if (p ==NULL)
{ p=CreaNodo();//si árbol vacío, crea la raíz
if (p==NULL) {printf("Error creación de nodo raíz"); exit(1);}
else {p->act=1;p->hoja=eshoja;p->clave[0]=valor;*pbt=p;}
}
else if(p->act==N)//nodo raíz lleno
{ s=CreaNodo();if (s==NULL) {printf("Error creación de nueva raíz"); exit(1);}
*pbt=s; s->hoja=esnodointerno; s->pn[0]=p;
split(s,0,p);
insertenolleno(s,valor);
}
else insertenolleno(p,valor);
}
Profesor Leopoldo Silva Bijit 20-01-2010

B-Trees 23
17.10. Descartar.
La función descartar puede descomponerse en funciones primitivas como desplazar a la derecha
o izquierda y mezclar dos nodos. Se muestran expandidas, para evitar el llamado a funciones.
int descartar(pnodo *pbt, int valor)
{ int i,j,kp;
pnodo y,z,c,x=*pbt;
if(x==NULL) {printf("Error en descartar: Arbol vacío\n"); return(1);}
if(x->hoja==eshoja)
{//borrar valor;
for(i=x->act-1;i>=0 && valor< x->clave[i];i--);
//i es la clave mayor o igual al valor
if( valor==x->clave[i] )
{
for(j=i;jact-1;j++) x->clave[j]=x->clave[j+1]; //mover claves en x;
x->act--;
if (debug) printf("Borrando %d en hoja\n", valor);
if(x->act==0) //B-Tree queda vacío
{ if (debug) printf("B-Tree queda vacío\n");
*pbt=NULL;
}
return(0);
}
else {printf("Error en descartar: clave %d no existe\n",valor); return(1);}
}
else //no es hoja
{
for(i=x->act-1;i>=0 && valorclave[i];i--);
//v está en x ssi:
if( i>=0 && valor==x->clave[i] ) //valor está en x->clave[i]. i está entre 0 y x->cnt-1
{ y=x->pn[i]; // y apunta al hermano izquierdo
z=x->pn[i+1]; // z apunta al hermano derecho.
if (y->act>N/2)
{ kp=y->clave[(y->act)-1]; //mayor descendiente hijo izquierdo
x->clave[i] =kp;
if (debug) printf("Borrando con préstamo izquierdo en nodo %d\n",kp);
descartar(&y,kp);
}
else if (z->act>N/2)
{kp=z->clave[0]; //menor descendiente hijo derecho
x->clave[i]=kp;
if (debug) printf("Borrando con préstamo derecho en nodo %d\n",kp);
descartar(&z,kp);
}
else //merge y con z
{y->clave[y->act]=x->clave[i]; y->act++;
Profesor Leopoldo Silva Bijit 20-01-2010

24 Estructuras de Datos y Algoritmos
//copiar los de z a continuación en y;
for(j=0;jact;j++) {y->clave[y->act+j]=z->clave[j];}
if (y->hoja==esnodointerno)
for(j=0;jact+1;j++) {y->pn[y->act+j]=z->pn[j];}//copia punteros
y->act+=z->act;
for(j=i;jact-1;j++) x->clave[j]=x->clave[j+1]; //mover claves en x;
for(j=i;jact;j++) x->pn[j]=x->pn[j+1];//desplaza punteros en x
x->act--;free(z);
if(x->act==0) //B-Tree disminuye altura
{free(x);
if (debug) printf("Disminuye altura B-Tree\n");
*pbt=y;
}
if (debug) printf("Borrando con fusión de derecho en nodo izquierdo %d\n",valor);
descartar(&y,valor);
}
}
else //valor está en un descendiente de x
//pn[i] apunta a la página en la que está el valor, o cuyos descendientes contienen el valor.
{i++; // ahora i es mayor o igual que cero
c=x->pn[i];
if(c->act==N/2) //nodo descendiente con claves mínimas
{
if(i==0) y=NULL; else y=x->pn[i-1]; //si c no tiene hermano izquierdo: y=NULL
if(i==x->act) z=NULL; else z=x->pn[i+1]; //si c no tiene hermano derecho: z=NULL
if(y!=NULL && y->act>N/2)
{ for(j=c->act; j>0;j--) c->clave[j]=c->clave[j-1]; //mueve c a la derecha
if(c->hoja==esnodointerno)
for(j=c->act+1;j>0;j--) c->pn[j]=c->pn[j-1]; //mueve punteros de c a la derecha
c->clave[0]=x->clave[i-1];//baja uno de x a c
c->act++; //c queda con mas de N/2.
x->clave[i-1]=y->clave[y->act-1]; //mayor de y lo sube a x
c->pn[0]=y->pn[y->act]; //hijo de y se cuelga como hijo de c
y->act--;
if (debug)
{ printf("Deja descendiente con más del mínimo\n");
PrtBtree(btree,1);
printf("Borrando %d en nodo descendiente con prestamo de izquierdo \n",valor);
}
descartar(&c,valor);
}//y es nulo o y no tiene (t-1)
else if (z!=NULL && z->act>N/2)
{ c->clave[c->act]=x->clave[i];//baja central de x a c.
c->act++; //c queda con mas de N/2.
c->pn[c->act]=z->pn[0]; //pega menores de z a mayores del mayor de c
Profesor Leopoldo Silva Bijit 20-01-2010

B-Trees 25
x->clave[i]=z->clave[0]; //el menor de z lo sube a x.
for(j=0;jact-1;j++) z->clave[j]=z->clave[j+1]; //mueve claves de z a la izquierda
if (z->hoja==esnodointerno)
for(j=0;jact;j++) z->pn[j]=z->pn[j+1];//mueve punteros de z a la izquierda
z->act--;
if (debug)
{ printf("Deja descendiente con más del mínimo\n");
PrtBtree(btree,1);
printf("Borrando %d en nodo descendiente con préstamo de derecho \n",valor);
}
descartar(&c,valor);
}
else //merge
{ if(y==NULL) //merge c con z;
{ c->clave[c->act]=x->clave[i]; c->act++;
for(j=0;jact;j++) {c->clave[c->act+j]=z->clave[j]; }
if(c->hoja==esnodointerno)
for(j=0;jact+1;j++) {c->pn[c->act+j]=z->pn[j]; }
c->act+=z->act;
//correr x (que no es hoja, tiene descendientes)
for(j=i;jact-1;j++) x->clave[j]=x->clave[j+1]; //mover claves a la izquierda en x;
for(j=i+1;jact;j++) x->pn[j]=x->pn[j+1];//desplaza punteros a la izquierda en x
x->pn[i]=c;
x->act--;
if(x->act==0) //B-Tree disminuye altura
{ free(x);
*pbt=c;
if (debug) printf("Disminuye altura\n");
}
free(z);
if (debug)
{ printf("mezcla c con z. Deja descendiente con más del mínimo por fusión\n");
PrtBtree(btree,1);
printf("Borrando %d en nodo descendiente con fusión de derecho \n",valor);
}
descartar(&c,valor);
}
else // merge c con y; Código es similar al del if.
{
y->clave[y->act]=x->clave[i-1]; y->act++;
for(j=0;jact;j++) {y->clave[y->act+j]=c->clave[j]; }
if (y->hoja==esnodointerno)
for(j=0;jact+1;j++) {y->pn[y->act+j]=c->pn[j]; }
y->act+=c->act;
//correr x
for(j=i-1;jact-1;j++) x->clave[j]=x->clave[j+1]; //mover claves en x;
Profesor Leopoldo Silva Bijit 20-01-2010

26 Estructuras de Datos y Algoritmos
for(j=i;jact;j++) x->pn[j]=x->pn[j+1];//desplaza punteros en x
x->pn[i-1]=y;
x->act--;
if(x->act==0) //B-Tree disminuye altura
{ free(x);
*pbt=y;
if (debug) printf("Disminuye altura\n");
}
free(c);
if (debug)
{ printf("mezcla c con y\n");
PrtBtree(btree,1);
printf("Borrando %d en nodo descendiente con fusión en izquierdo \n",valor);
}
descartar(&y,valor);
}
}
}
else //nodo descendiente con claves mayores que el número mínimo. ( >= t)
{
if (debug) printf("Borrando %d en nodo descendiente con más claves que el
mínimo\n",valor);
descartar(&c,valor);
}
}
return(0); //finalizan recursiones por el fondo.
}
}
17.11. Test de las funciones.
pnodo btree=NULL;
int main(void)
{ int i;
/* Test básico
PrtNodo(btree);
descartar(&btree,1);
inserte(&btree,1);
PrtNodo(btree);
descartar(&btree,1);
PrtNodo(btree);
*/
for(i=1;i0;i--) descartar(&btree,i);
Profesor Leopoldo Silva Bijit 20-01-2010

B-Trees 27
for(i=1;i0;i--) descartar(&btree,i);
//test de búsquedas
for(i=1;i

28 Estructuras de Datos y Algoritmos
Índice general.
CAPÍTULO 17. ........................................................................................................................................... 1
B-TREES. .................................................................................................................................................... 1
17.1 DEFINICIÓN DE B-TREES DE GRADO T. .............................................................................................. 1
17.2. CÁLCULO DE LA ALTURA DE UN B-TREE. ......................................................................................... 1
17.3. REQUERIMIENTOS DE ESPACIO Y RELACIONES DE ORDENAMIENTO DE LAS CLAVES.......................... 3
17.4. COMPLEJIDAD EN LA BÚSQUEDA. ..................................................................................................... 4
17.5 ANÁLISIS DE LA OPERACIÓN INSERCIÓN. ........................................................................................... 5
17.5.1 Ejemplo de inserción en un 2-4-Tree. ....................................................................................... 5
17.5.2 Análisis de inserción en un B-Tree de grado t. ......................................................................... 7
a) Árbol vacío. ................................................................................................................................................. 7
b) Inserción en hoja con menos de (2t-1) claves. ............................................................................................. 7
c) Inserción en nodo interno. ............................................................................................................................ 8
c1) Si ancestro no está completo ................................................................................................................. 8
c2) Si el ancestro de v, está completo. ......................................................................................................... 8
c3) Si p es la raíz y está completa.............................................................................................................. 10
17.5.3 Costo de la inserción. .............................................................................................................. 10
17.6 ANÁLISIS DE LA OPERACIÓN DESCARTAR. ....................................................................................... 10
17.6.1. Descarte en hoja con más claves que el mínimo número. ...................................................... 11
17.6.2. Descarte en nodo p que no es hoja y que contiene la clave v. ............................................... 11
Hijo izquierdo con más claves que la mínima. ............................................................................................... 12
Hijo derecho con más claves que la mínima. ................................................................................................. 12
Ambos hijos con número de claves mínimas. ................................................................................................ 13
Nodo raíz con claves mínimas. ...................................................................................................................... 13
Nodo raíz con una sola clave.......................................................................................................................... 14
17.6.3. Descarte en nodo p que no es hoja y que no contiene la clave v. .......................................... 15
Ancestro de v, tiene más de (t-1) claves. ........................................................................................................ 15
Hermano izquierdo de ancestro de v, tiene más de (t-1) claves. ..................................................................... 15
Hermano derecho de ancestro de v, tiene más de (t-1) claves. ....................................................................... 16
Hermanos de ancestro de v, tienen (t-1) claves. ............................................................................................. 17
Si existe el hermano izquierdo .................................................................................................................. 17
Si no existe el hermano izquierdo. ............................................................................................................ 18
17.6.4. Complejidad de la operación descarte. .................................................................................. 18
17.7. ÁRBOLES COLOREADOS. ................................................................................................................. 18
17.8. ESTRUCTURA DE DATOS Y FUNCIONES BÁSICAS. ............................................................................ 20
17.8.1. Estructura de datos. .............................................................................................................. 20
17.8.2. Creación de un nodo. ............................................................................................................ 20
17.8.4. Mostrar nodo y el B-Tree en niveles. ..................................................................................... 20
17.8.5. Búsqueda de un valor. ............................................................................................................ 21
17.8.6. Partir un nodo. ....................................................................................................................... 21
17.8.7. Inserción en nodo que no está lleno. ...................................................................................... 22
17.9. INSERCIÓN. ..................................................................................................................................... 22
17.10. DESCARTAR.................................................................................................................................. 23
17.11. TEST DE LAS FUNCIONES. ............................................................................................................. 26
REFERENCIAS. ......................................................................................................................................... 27
Profesor Leopoldo Silva Bijit 20-01-2010

B-Trees 29
ÍNDICE GENERAL. ................................................................................................................................... 28
ÍNDICE DE FIGURAS. ................................................................................................................................ 29
Índice de figuras.
FIGURA 17.1 B-TREE CON (T-1) CLAVES EN UN NODO. CADA NODO TIENE T HIJOS. ....................................... 1
FIGURA 17.2 B-TREE CON MÁXIMO NÚMERO DE CLAVES EN CADA NODO, CON T=4. ..................................... 2
FIGURA 17.3 ALTURA DE B-TREE CON T=4. .................................................................................................. 3
FIGURA 17.4 CLAVES MÁXIMAS Y MÍNIMAS ALMACENADAS EN B-TREE CON T=4. ....................................... 3
FIGURA 17.5 ESQUEMA DE B-TREE CON T=2. ................................................................................................ 4
FIGURA 17.6. B-TREE DESPUÉS DE INGRESAR LA CLAVE 4, 5 Y 7. ................................................................. 5
FIGURA 17.7. B-TREE DESPUÉS DE INGRESAR LA CLAVE 8, Y 10. .................................................................. 6
FIGURA 17.8. B-TREE DESPUÉS DE INGRESAR LA CLAVE 11, Y 13. ................................................................ 6
FIGURA 17.9. B-TREE DESPUÉS DE INGRESAR LA CLAVE 14. ......................................................................... 6
FIGURA 17.10 B-TREE DESPUÉS DE INGRESAR LA CLAVE 16. ........................................................................ 6
FIGURA 17.11 B-TREE DESPUÉS DE INGRESAR LA CLAVE 17. ........................................................................ 6
FIGURA 17.12 B-TREE DESPUÉS DE INGRESAR LA CLAVE 25. ........................................................................ 7
FIGURA 17.13 B-TREE DESPUÉS DE INGRESAR LA CLAVE 26. ........................................................................ 7
FIGURA 17.14 INSERCIÓN EN HOJA QUE NO ESTÁ LLENA. .............................................................................. 8
FIGURA 17.15 DESPUÉS DE INSERTAR V EN HOJA QUE NO ESTABA LLENA. .................................................... 8
FIGURA 17.16 DESCENDER A UN NODO QUE ESTÁ COMPLETO. ...................................................................... 9
FIGURA 17.17 DESPUÉS DE PARTIR ANCESTRO DE V. ..................................................................................... 9
FIGURA 17.18 INSERCIÓN EN RAÍZ COMPLETA. ........................................................................................... 10
FIGURA 17.19 DESPUÉS DE INTENTAR INSERTAR EN RAÍZ COMPLETA. ........................................................ 10
FIGURA 17.20. HOJA CON MÁS DE (T-1) CLAVES. ........................................................................................ 11
FIGURA 17.21. NODO INTERNO CON MÁS DE (T-1) CLAVES, Y CLAVE CON HIJO IZQUIERDO Y DERECHO. ..... 12
FIGURA 17.21A. SE RECURRE A BORRAR EL PREDECESOR DE V. .................................................................. 12
FIGURA 17.21B. SE RECURRE A BORRAR EL SUCESOR DE V. ........................................................................ 13
FIGURA 17.22. MEZCLA DEL HIJO IZQUIERDO Y DERECHO. ......................................................................... 13
FIGURA 17.23. HIJOS CON CLAVES MÍNIMAS, RAÍZ CON DOS ELEMENTOS. .................................................. 14
FIGURA 17.24. FUSIÓN DE HIJOS. ................................................................................................................ 14
FIGURA 17.25. HIJOS CON CLAVES MÍNIMAS, RAÍZ CON UN ELEMENTO. ...................................................... 14
FIGURA 17.26. NUEVA RAÍZ, Y FUSIÓN DE HIJOS. ........................................................................................ 15
FIGURA 17.27. DESCARTE EN NODO INTERNO QUE NO CONTIENE LA CLAVE BUSCADA. .............................. 15
FIGURA 17.28. PRÉSTAMO DEL HERMANO IZQUIERDO. ............................................................................... 16
FIGURA 17.29. PRÉSTAMO DEL HERMANO DERECHO. .................................................................................. 17
FIGURA 17.30. FUSIÓN DEL ANCESTRO CON EL HERMANO IZQUIERDO. ....................................................... 17
FIGURA 17.31. FUSIÓN DEL ANCESTRO CON EL HERMANO DERECHO. ......................................................... 18
FIGURA 17.32. ÁRBOL BINARIO COLOREADO. ............................................................................................. 19
FIGURA 17.33. COLOREADO CON ROJOS HORIZONTALES............................................................................. 19
FIGURA 17.34. B-TREE DE GRADO DOS, EQUIVALENTE DEL COLOREADO DE LA FIGURA 17.32. .................. 19
Profesor Leopoldo Silva Bijit 20-01-2010