Arvores B , B+ e B*

Fagner, Jonas Mayer e Pedro

Universidade Regional Integrada – Curso de Ciência da Computação – Campus SantiagoAv. Batista Sobrinho, s/n – CEP 97700-000 – Santiago – RS

Resumo

A elaboração do artigo a partir de uma pesquisa bibliografia , tendo como objetivo apresentar algumas variações da estrutura de dados não-linear árvore Uma arvore é extremamente útil para certos tipos de computação. Por exemplo, as arvores podem ser usadas para representar expressões aritméticas. Este artigo apresenta as arvore B e suas varições , que são muito usadas em banco de dados e em sistemas de arquivos, e seus respectivos exemplos em Java.

Palavras-chave: B ; arvore ; Java; estrutura de dados.

1. Introdução

Arvores B são árvores balanceadas projetadas para trabalhar com dispositivos de armazenamento secundário e banco de dados. Elas visam otimizar as operações de entrada e saída nos dispositivos.

O criador das árvores B, Rudolf Bayer, não definiu claramente de onde veio o B das árvores B. Ao que parece, o B vem de balanceamento onde todos os nós da árvore estão em um mesmo nível. Também é possível que o B tenha vindo de seu sobrenome Bayer, ou ainda do nome da empresa onde trabalhava Boeing, no Boeing Scientific Research Labs

2. Arvores B

As arvores B são arvores M-múltipla de buscas balanceadas.Diferente das árvores binárias, cada nó em uma árvore B pode ter muitos filhos, isto é, o

grau de um nó pode ser muito grande. Características Uma árvore B de ordem "m" é uma árvore que atende as seguintes propriedades:

1. Cada nó tem no máximo "m" filhos2. Cada nó (exceto a raiz e as folhas) tem pelo menos "m/2" filhos3. A raiz tem pelo menos dois filhos se ela mesma não for uma folha4. Todas as folhas aparecem no mesmo nível e carregam informação5. Um nó não-folha com "k" filhos deve ter k-1 chaves

3. Arvores B+

A árvore B+ é uma variação da estrutura básica da árvore B. A árvore B+ é como uma árvore B, mas os nós internos possuem apenas chaves (sem os valores associados a elas). As chaves são repetidas na árvore de forma que no nível das folhas todas as chaves estão presentes, assim como todos os valores associados a elas (os valores usualmente são apenas ponteiros).

Com essa estrutura, é possível adicionar um ponteiro de cada folha para a folha seguinte, criando uma lista ligada de folhas que possuem todos os dados ordenados. Isso permite a utilização sequencial dos dados de forma mais eficiente e com menos acessos em disco. Possivelmente pode ser útil ter ponteiros também na outra direção, criando uma lista duplamente ligada no nível das folhas.

De certa forma, a árvore B+ pode ser vista como todos os dados dispostos sequencialmente e agrupados em blocos em uma lista ligada (nível das folhas) com um índice estruturado em forma de uma árvore de busca balanceada e eficiente em cima (nós internos).

Características:1. Todas as chaves são mantidas em folhas;2. As chaves são repetidas em nós não-folha formando um índice;3. As folhas são ligadas oferecendo um caminho seqüencial para percorrer as chaves.

4. Arvore B*

Uma árvore B* é como uma árvore B, mas em que a restrição da capacidade é mais forte. Na árvore B é como se estivermos forçando a utilização de pelo menos 1/2 da capacidade de cada nó. A árvore B* modifica esse limite inferior para 2/3. Isso é possível complicando-se os algoritmos envolvidos (não achei em nenhuma fonte, mas acho que a complexidade não muda).

Por exemplo, no caso de uma árvore B, quando tentamos inserir em um nó que está cheio, o primeiro passo é quebrar o nó em dois, um com [m/2] chaves e o outro com [m/2] (e a chave extra sobe). No caso da árvore B* ocorre remanejamentos até que, não apenas o nó atual esteja cheio, como o seu vizinho também. Nesse caso, os dois nós são divididos em três.

5. Exemplo de Arvore B

//campos de btree , construtor e métodos attachsubtreepublic class BTree

extends MWayTree{

protected BTree parent;

public BTree (int m){ super(m); }

public void attachSubtree (int i, MWayTree arg ){

BTree btree = (BTree) arg;subtree[i] = btree;btree.parent = this;

}//...

}//fim//Método insert da classe Btreepublic class Btree

extends MWayTree{

protected BTree parent;public void insert (Comparable object){

if (isEmpy ( )){

if (parent == null){

attachSubtree (0, new BTree (getM ( )));key [i] = object;attachSubtree (1, new BTree ( getM ( ))):count = 1;

}else

parent.insertPair (object , new BTree (getM( )));}else{

int index = findIndex (object);if (index != 0 \&\& object.isEQ( key [index]}}

throw new IllegalArgumentException("duplicate key");

subtree[index].insert(object);}

}}//fim

//Método insertPair da classe BTreepublic class BTree extends MWayTree{ protected BTree parent;

protected void insertPair (Comparable object, BTree child) { int index = findIndex (object); if (!isFull ()) { insertKey (index + 1, object); insertSubtree (index + 1, child); ++count; } else { Comparable extraKey = insertKey (index + 1, object); BTree extraTree = insertSubtree (index + 1, child); if (parent == null) { BTree left = new BTree (getM ()); BTree right = new BTree (getM ()); left.attachLeftHalfOf (this); right.attachRightHalfOf (this); right.insertPair (extraKey, extraTree); attachSubtree (0, left); key [1] = key [(getM () + 1)/2]; attachSubtree (1, right);

count = 1; } else { count = (getM () + 1)/2 - 1; BTree right = new BTree (getM ()); right.attachRightHalfOf (this); right.insertPair (extraKey, extraTree); parent.insertPair (key [(getM () + 1)/2], right); } } } // ...}

6. Conclusão As arvores B são uma boa alternativa pois possuem um melhor desempenho e ocupa menos espaço em relação as arvores binarias , ela é mais veloz nas buscas pela utilização de chaves primarias e no acesso de dados. Porem as arvore B+ tem uma maior performance em busca linear, porque sempre mantem uma copia dos dados nas folhas.

Referências

PRESIS Bruno Estruturas de dados e Algoritmos Padrões de projeto orientados a objetos com Java Rio de janeiro ,2000

UMAMÃO http://umamao.com/questions/Quais-s%C3%A3o-as-diferen%C3%A7as-entre-%C3%A1rvores-B-B-e-B/answers/4ce85e1979de4f0bab001038