Ver el código de «Árbol-B»

[[Archivo:B-tree.svg|thumb|400px|right|Ejemplo de árbol B.]] 
En las [[ciencias de la computación]], los '''árboles-B''' o '''B-árboles''' son [[Árbol (programación)|estructuras de datos de árbol]] que se encuentran comúnmente en las implementaciones de [[bases de datos]] y [[sistemas de archivos]]. Al igual que los [[árbol binario de búsqueda|árboles binarios de búsqueda]], son árboles balanceados de búsqueda, pero cada nodo puede poseer más de dos hijos.<ref>${{Obra citada|last =Cormen|first = Thomas|author-link = Thomas H. Cormen|last2 = Leiserson|first2 = Charles|author2-link = Charles E. Leiserson|last3 = Rivest|first3 = Ronald|author3-link = Ronald L. Rivest|last4 = Stein|first4 = Clifford|author4-link = Clifford Stein|title = Introduction to Algorithms|place =|publisher = MIT Press and McGraw-Hill|year = 2001|pages = 434–454|isbn = 0-262-03293-7}}</ref> Los árboles B mantienen los datos ordenados y las inserciones y eliminaciones se realizan en tiempo logarítmico amortizado.

== Definición ==
La idea tras los árboles-B es que los nodos internos deben tener un número variable de nodos hijo dentro de un rango predefinido. Cuando se inserta o se elimina un dato de la estructura, la cantidad de nodos hijo varía dentro de un nodo. Para que siga manteniéndose el número de nodos dentro del rango predefinido, los nodos internos se juntan o se parten. Dado que se permite un rango variable de nodos hijo, los árboles-B no necesitan rebalancearse tan frecuentemente como los [[Árbol binario de búsqueda auto-balanceable|árboles binarios de búsqueda auto-balanceables]]. Pero, por otro lado, pueden desperdiciar memoria, porque los nodos no permanecen totalmente ocupados. Los límites (uno superior y otro inferior) en el número de nodos hijo son definidos para cada implementación en particular. Por ejemplo, en un '''árbol-B 2-3''' (A menudo simplemente llamado [[árbol 2-3]] ), cada nodo sólo puede tener 2 o 3 nodos hijos.

Un árbol-B se mantiene balanceado porque requiere que todos los nodos hoja se encuentren a la misma altura.

Los árboles B tienen ventajas sustanciales sobre otras implementaciones cuando el tiempo de acceso a los nodos excede al tiempo de acceso entre nodos. Este caso se da usualmente cuando los nodos se encuentran en dispositivos de [[almacenamiento secundario]] como los [[disco rígido|discos rígidos]]. Al maximizar el número de nodos hijo de cada nodo interno, la altura del árbol decrece, las operaciones para balancearlo se reducen, y aumenta la eficiencia. Usualmente este valor se coloca de forma tal que cada nodo ocupe un [[bloque de disco]], o un tamaño análogo en el dispositivo. Mientras que los árboles B 2-3 pueden ser útiles en la memoria principal, y además más fáciles de explicar, si el tamaño de los nodos se ajusta para caber en un bloque de disco, el resultado puede ser un árbol B 129-513.

Los creadores del árbol B, [[Rudolf Bayer]] y [[Ed McCreight]], no han explicado el significado de la letra ''B'' de su nombre. Se cree que la ''B'' es de ''balanceado'', dado que todos los nodos hoja se mantienen al mismo nivel en el árbol. La ''B'' también puede referirse a ''Bayer'', o a [[Boeing]], porque sus creadores trabajaban en los ''Boeing Scientific Research Labs'' por ese entonces.

== Definición técnica ==
B-árbol es un árbol de búsqueda que puede estar vacío o aquel cuyos nodos pueden tener varios hijos, existiendo una relación de orden entre ellos, tal como muestra el dibujo. 
      
Un árbol-B de orden M (el máximo número de hijos que puede tener cada nodo) es un árbol que satisface las siguientes propiedades:

# Cada nodo tiene como máximo M hijos.
# Cada nodo (excepto raíz) tiene como mínimo (M)/2 claves.
# La raíz tiene al menos 2 hijos si no es un nodo hoja. (según M)
# Todos los nodos hoja aparecen al mismo nivel.
# Un nodo no hoja con k hijos contiene k-1 elementos almacenados.
# Los hijos que cuelgan de la raíz (r1, ···, rm) tienen que cumplir ciertas condiciones: 
## El primero tiene valor menor que r1.
## El segundo tiene valor mayor que r1 y menor que r2, etc.
## El último hijo tiene valor mayor que rm.

== Altura: El mejor y el peor caso ==
En el mejor de los casos, la altura de un árbol-B es:
: <math>\log_{M} n</math>
En el peor de los casos, la altura de un árbol-B es:
: <math>n</math> 
Donde M es el número máximo de hijos que puede tener un nodo.

== Estructura de los nodos ==
Cada elemento de un nodo interno actúa como un valor separador, que lo divide en subárboles. Por ejemplo, si un nodo interno tiene tres nodos hijo, debe tener dos valores separadores o elementos ''a''<sub>1</sub> y ''a''<sub>2</sub>. Todos los valores del subárbol izquierdo deben ser menores a ''a''<sub>1</sub>, todos los valores del subárbol del centro deben estar entre ''a''<sub>1</sub> y ''a''<sub>2</sub>, y todos los valores del subárbol derecho deben ser mayores a ''a''<sub>2</sub>.

Los nodos internos de un árbol B, es decir los nodos que no son hoja, usualmente se representan como un conjunto ordenado de elementos y punteros a los hijos. Cada nodo interno contiene un máximo de ''U'' hijos y, con excepción del nodo raíz, un mínimo de ''L'' hijos. Para todos los nodos internos exceptuando la raíz, el número de elementos es uno menos que el número de punteros a nodos. El número de elementos se encuentra entre ''L-1'' y ''U-1''. El número ''U'' debe ser 2''L'' o 2''L''-1, es decir, cada nodo interno está por lo menos a medio llenar. Esta relación entre ''U'' y ''L'' implica que dos nodos que están a medio llenar pueden juntarse para formar un nodo legal, y un nodo lleno puede dividirse en dos nodos legales (si es que hay lugar para subir un elemento al nodo padre). Estas propiedades hacen posible que el árbol B se ajuste para preservar sus propiedades ante la inserción y eliminación de elementos.

Los nodos hoja tienen la misma restricción sobre el número de elementos, pero no tienen hijos, y por tanto carecen de punteros.

El nodo raíz tiene límite superior de número de hijos, pero no tiene límite inferior. Por ejemplo, si hubiera menos de ''L-1'' elementos en todo el árbol, la raíz sería el único nodo del árbol, y no tendría hijos.

Un árbol B de altura ''n+1'' puede contener ''U'' veces por elementos más que un árbol B de profundidad ''n'', pero el costo en la búsqueda, inserción y eliminación crece con la altura del árbol. Como todo árbol balanceado, el crecimiento del costo es más lento que el del número de elementos.

Algunos árboles balanceados guardan valores sólo en los nodos hoja, y por lo tanto sus nodos internos y nodos hoja son de diferente tipo. Los árboles B guardan valores en cada nodo, y pueden utilizar la misma estructura para todos los nodos. Sin embargo, como los nodos hoja no tienen hijos, una estructura especial para estos mejora el funcionamiento.

;Class nodo árbol B en c++
<!-- [[Imagen:nodoarbol-bc++.png|nodoarbol-bc++.png]] -->

<syntaxhighlight lang="cpp">
#define TAMANO 1000

struct stclave {
    int valor;
    long registro;
};

class bnodo {
  public:
    bnodo (int nClaves); // Constructor
    ~bnodo ();           // Destructor

  private:
    int clavesUsadas;    
    stclave *clave;      
    bnodo **puntero;     
    bnodo *padre;        

  friend class btree;
};
</syntaxhighlight>

== Algoritmos ==
=== Búsqueda ===
La búsqueda es similar a la de los árboles binarios. Se empieza en la raíz, y se recorre el árbol hacia abajo, escogiendo el sub-nodo de acuerdo a la posición relativa del valor buscado respecto a los valores de cada nodo. Típicamente se utiliza la [[búsqueda binaria]] para determinar esta posición relativa.
; Procedimiento
[[Archivo:arbolbins.png|thumb|300px|right|ejemplo2 inserción en árbol B.]]
# Situarse en el nodo raíz.
# (*) Comprobar si contiene la clave a buscar.
## Encontrada fin de procedimiento.
## No encontrada:
### Si es hoja no existe la clave.
### En otro caso el nodo actual es el hijo que corresponde:
#### La clave a buscar k < k1: hijo izquierdo.
#### La clave a buscar k > ki y k < ki+1 hijo iésimo.
#### Volver a paso 2(*).

=== Inserción ===
Las inserciones se hacen en los nodos hoja.

# Realizando una búsqueda en el árbol, se halla el nodo hoja en el cual debería ubicarse el nuevo elemento.
# Si el nodo hoja tiene menos elementos que el máximo número de elementos legales, entonces hay lugar para uno más. Inserte el nuevo elemento en el nodo, respetando el orden de los elementos.
# De otra forma, el nodo debe ser dividido en dos nodos. La división se realiza de la siguiente manera: 
## Se escoge el valor medio entre los elementos del nodo y el nuevo elemento. 
## Los valores menores que el valor medio se colocan en el nuevo nodo izquierdo, y los valores mayores que el valor medio se colocan en el nuevo nodo derecho; el valor medio actúa como valor separador. 
## El valor separador se debe colocar en el nodo padre, lo que puede provocar que el padre sea dividido en dos, y así sucesivamente.
Si las divisiones de nodos suben hasta la raíz, se crea una nueva raíz con un único elemento como valor separador, y dos hijos. Es por esto por lo que la cota inferior del tamaño de los nodos no se aplica a la raíz. El máximo número de elementos por nodo es ''U''-1. Así que debe ser posible dividir el número máximo de elementos ''U''-1 en dos nodos legales. Si este número fuera impar, entonces ''U''=2''L'', y cada uno de los nuevos nodos tendrían (''U''-2)/2 = ''L''-1 elementos, y por lo tanto serían nodos legales. Si ''U''-1 fuera par, ''U''=2''L''-1, así que habría 2''L''-2 elementos en el nodo. La mitad de este número es ''L''-1, que es el número mínimo de elementos permitidos por nodo.

Un algoritmo mejorado admite una sola pasada por el árbol desde la raíz, hasta el nodo donde la inserción tenga lugar, dividiendo todos los nodos que estén llenos encontrados a su paso. Esto evita el costo de volver a cargar en memoria los nodos padres (lo que puede llegar a ser caro si los nodos se encuentran en una memoria secundaria). Sin embargo, para usar este algoritmo mejorado, debemos ser capaces de enviar un elemento al nodo padre y dividir el resto ''U''-2 elementos en 2 nodos legales, sin añadir un nuevo elemento. Esto requiere que ''U''=2''L'' en lugar de ''U''=''L''-1, lo que explica por qué algunos libros de texto imponen este requisito en la definición de árboles-B.

=== Eliminación ===

La eliminación de un elemento es directa si no se requiere corrección para garantizar sus propiedades. Hay dos estrategias populares para eliminar un nodo de un árbol B.
* localizar y eliminar el elemento, y luego corregir, o
* hacer una única pasada de arriba abajo por el árbol, pero cada vez que se visita un nodo, reestructurar el árbol para que cuando se encuentre el elemento a ser borrado, pueda eliminarse sin necesidad de continuar reestructurando
Se pueden dar dos problemas al eliminar elementos. Primero, el elemento puede ser un separador de un nodo interno. Segundo, puede suceder que al borrar el elemento número de elementos del nodo quede debajo de la cota mínima. Estos problemas se tratan a continuación en orden.
==== Eliminación en un nodo hoja ====

* Busque el valor a eliminar.
* Si el valor se encuentra en un nodo hoja, se elimina directamente la clave, posiblemente dejándolo con muy pocos elementos; por lo que se requerirán cambios adicionales en el árbol.

[[Archivo:Arbolbelimnodom.jpg|thumb|300px|right|eliminar clave 20 de un nodo interno.]]

==== Eliminación en un nodo interno ====
(recursivamente) del nuevo nodillo.

En el segundo caso, uno de los dos nodos hijos tienen un número de elementos mayor que el mínimo. Entonces izquierdo o el menor elemento del nuevo separador.
* Como se ha eliminado un elemento de un nodo hoja, se trata este caso de manera equivalente.

=== Rebalanceo después de la eliminación ===
Si al eliminar un elemento de un nodo hoja el nodo se ha quedado con menos elementos que el mínimo permitido, algunos elementos se deben redistribuir. En algunos casos el cambio lleva la deficiencia al nodo padre, y la redistribución se debe aplicar iterativamente hacia arriba del árbol, quizá incluso hasta a la raíz. Dado que la cota mínima en el número de elementos no se aplica a la raíz, el problema desaparece cuando llega a esta.

=== Construcción Inicial ===
En aplicaciones, es frecuentemente útil construir un árbol-B para representar un gran número de datos existentes y después actualizarlo de forma creciente usando operaciones estándar de los árboles-B. En este caso, el modo más eficiente para construir el árbol-B inicial no sería insertar todos los elementos en el conjunto inicial sucesivamente, sino construir el conjunto inicial de nodos hoja directamente desde la entrada, y después construir los nodos internos a partir de este conjunto. Inicialmente, todas las hojas excepto la última tienen un elemento más, el cual será utilizado para construir los nodos internos.
Por ejemplo, si los nodos hoja tienen un tamaño máximo de 4 y el conjunto inicial es de enteros desde el 1 al 24, tenemos que construir inicialmente
5 nodos hoja conteniendo 5 valores cada uno (excepto el último que contiene 4):
{|
|-
|
{|class="wikitable"
|1||2||3||4||5
|}
|
{|class="wikitable"
|6||7||8||9||10
|}
|
{|class="wikitable"
|11||12||13||14||15
|}
|
{|class="wikitable"
|16||17||18||19||20
|}
|
{|class="wikitable"
|21||22||23||24
|}
|}
Construiremos el siguiente nivel hacia arriba desde las hojas tomando el último elemento de cada hoja excepto el último. De nuevo, cada nodo excepto el último contendrá un valor más. En el ejemplo, es supuesto que los nodos internos contienen como mucho 2 valores (por lo que pueden tener 3 hijos). Luego el siguiente nivel de nodos internos nos quedaría de la siguiente manera:

{|
|-
|
{|class="wikitable"
|5||10||15
|}
|
{|class="wikitable"
|20
|}
|}

{|
|-
|
{|class="wikitable"
|1||2||3||4
|}
|
{|class="wikitable"
|6||7||8||9
|}
|
{|class="wikitable"
|11||12||13||14
|}
|
{|class="wikitable"
|16||17||18||19
|}
|
{|class="wikitable"
|21||22||23||24
|}
|}

Este proceso se continuará hasta que alcancemos un nivel con un solo nodo y no está sobrecargado. En nuestro ejemplo solo nos quedaría el nivel de la raíz:

{|
|-
|
{|class="wikitable"
|15
|}
|}

{|
|-
|
{|class="wikitable"
|5||10
|}
|
{|class="wikitable"
|20
|}
|}

{|
|-
|
{|class="wikitable"
|1||2||3||4
|}
|
{|class="wikitable"
|6||7||8||9
|}
|
{|class="wikitable"
|11||12||13||14
|}
|
{|class="wikitable"
|16||17||18||19
|}
|
{|class="wikitable"
|21||22||23||24
|}
|}

== Notas ==
Cada nodo tendrá siempre entre ''L'' y ''U'' hijos incluidos con una excepción: El nodo raíz debe tener entre 2 y ''U'' hijos. En otras palabras, la raíz está exenta de la restricción del límite inferior. Esto permite al árbol sostener un pequeño número de elementos. Un nodo raíz con un solo hijo no tendría sentido, ya que podríamos añadírselo a la raíz. Un nodo raíz sin hijos es también innecesario, ya que un árbol sin hijos se suele representar sin raíz.

=== Multi-modo:combinar y dividir ===
Es posible modificar el algoritmo anterior, cuando tratamos de encontrar más elementos para un nodo al que le faltan, examinamos a los hermanos, y si alguno tiene más del valor mínimo de números, reordenamos los valores de los hermanos de un extremo a otro para rellenar al mínimo el nodo al que le faltan.
De la misma manera, cuando un nodo se divide, los elementos extra pueden ser movidos cerca, por ejemplo a hermanos menos poblados; o la división puede dar lugar a un número de hermanos, redistribuyendo los elementos entre ellos en lugar de dividir un nodo.

En la práctica, el uso más común de los árboles-B implica mantener los nodos una memoria secundaria, donde será lento acceder a un nodo que no haya sido usado con anterioridad. Utilizando solo divisiones y combinaciones, disminuimos el número de nodos que se necesitan para la mayoría de situaciones comunes, pero podrían ser útiles en otras.

=== Relación entre U y L ===
Es casi universal el dividir nodos eligiendo un elemento medio y creando dos nuevos nodos. Esto limita la relación entre ''L'' y ''U''. Si intentamos insertar un elemento dentro de un nodo con ''U'' elementos, esto conlleva una redistribución de ''U'' elementos. Uno de estos, el intermedio, será trasladado al nodo padre, y los restantes serán divididos equitativamente, en la medida de lo posible, entre los dos nuevos nodos.

Por ejemplo, en un árbol-B 2-3, añadiendo un elemento a un nodo que ya contiene 3 hijos, y por consiguiente 2 valores separadores (padres), da lugar a 3 valores (los dos separadores y el nuevo valor). El valor medio se convierte en el nuevo separador (padre), y los otros valores se hacen independientes y con 2 hijos. Por lo general, si ''U'' es impar, cada uno de los nuevos nodos tienen (''U''+2)/2 hijos. Si ''U'' es par, unos tiene ''U''/2 hijos y el otro ''U''/2+1.

Si un nodo está completo y se divide exactamente en 2 nodos, ''L'' debe tener un tamaño permitido, lo suficiente pequeño, una vez q el nodo ha sido divido. También es posible dividir nodos completos en más de dos nodos nuevos. Eligiendo dividir un nodo en más de 2 nodos nuevos requerirá un valor más pequeño para ''L'' para el mismo valor de ''U''.
Como ''L'' se hace más pequeño, esto permite que haya más espacio sin usar en los nodos. Esto disminuirá la frecuencia de división de nodos, pero de la misma manera aumentará la cantidad de memoria que se necesita para almacenar el mismo número de valores, y el número de nodos que tienen que ser examinados para una operación particular.

=== Acceso concurrente ===
Lehman y Yao nos mostraron que, uniendo los bloques de árboles en cada nivel con un puntero al siguiente nivel (en una estructura de árbol donde los permisos, de lectura de los bloques del árbol, se pueden evitar porque el árbol desciende desde la raíz hasta las hojas por búsqueda e inserción), los permisos de escritura solo se requieren cuando un bloque del árbol es modificado. Minimizar los permisos a un nodo colgante simple solo durante su modificación, ayuda a maximizar el acceso concurrente por múltiples usuarios. Este dato se tiene en cuenta en bases de datos como, por ejemplo, ISAM (Métodos Indexados de Acceso Secuencial).

== Véase también ==
* [[Árbol (estructura de datos)|Árbol]]
* [[Árbol binario]]
* [[Árbol-B+]]
* [[Árbol-B*]]
* [[Partición de espacio binario]]
* [[Árbol rojo-negro]]
* [[Árbol AA]]
* [[Skip list]]

== Referencias ==
{{listaref}}

== Enlaces externos ==
* [https://web.archive.org/web/20060601041338/http://www.cse.ohio-state.edu/~bondhugu/acads/234-tree/index.shtml Ejemplo de funcionamiento del árbol 2-3-4 (la variante más simple de árbol-B)] (en inglés)
* [http://slady.net/java/bt/ Applet de ejemplo del funcionamiento del árbol B] (en inglés)
* [https://web.archive.org/web/20070120081516/http://usuarios.lycos.es/arbolesbpro/ Tutorial sobre árboles B]
* [http://mmengineer.blogspot.com/2007/12/indexacion-java-estructura-de-datos.html Indexación de datos con árbol B en Java]

{{Control de autoridades}}
[[Categoría:Árboles (estructura)|B, Arbol]]
[[Categoría:Introducciones relacionadas a la ciencia de la computación de 1971]]