Estrutura de

Dados

Profa. Dra. Vera Prudência Caminha

veraprudencia@id.uff.br

ICEx/UFF

Volta Redonda-RJ
© 2002-2020
 Estrutura de Dados

Sumário

Árvores Enraizadas ................................................................................. 03

Árvores m-árias ........................................................................................ 06
Árvores Binárias …………..…………………………………………………. 08
Percurso em árvores binárias ................................................................. 09
Exercícios ………………………………………………………………………. 10
Árvores Binárias de Busca....................................................................... 14
Exercícios ………………………………………………………………………. 19
Árvores Balanceadas ………………………………………………………… 20
Árvores AVL ............................................................................................. 20
Árvores B…………...………………………………………………………… 23
Exercícios ……………………………………………………………………… 26

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 2
 Estrutura de Dados

ÁRVORES ENRAIZADAS

1. Introdução

Em diversas aplicações, necessita-se de estruturas mais complexas. Entre

essas, destacam-se as árvores, por existirem inúmeros problemas práticos que
podem ser modelados através delas. Elas são a base para estruturas e operações
usadas em todos os aspectos de programação, desde a estrutura de programas
para compiladores, processamento de dados, recuperação de informação e
Inteligência Artificial. Árvores possuem tratamento computacional simples e
eficiente.

2. Definições Básicas

Uma árvore enraizada T, ou simplesmente árvore, é um conjunto finito

de elementos denominados nós ou vértices tais que:
i. T = 0 é a árvore vazia ou
ii. Existe um nó especial r, chamado raiz de T, os nós restantes
constituem um conjunto vazio ou são divididos em conjuntos de um ou
mais subconjuntos disjuntos não vazios, as subárvores de r, ou
simplesmente subárvores, cada qual por sua vez sendo uma árvore
também.

3. Representação

1. Diagrama de Inclusão

Raiz=A

2. Parênteses Aninhados

(A(B)(C(D(G)(H))(E)(F(I))))

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 3
 Estrutura de Dados

3. Forma Hierárquica

Ex:
raiz
A

B C

D E F

G I
H

Se v é um vértice qualquer, representa-se por Tv a subárvore com raiz em v.

Ex: TD = {D, G, H}

A árvore T possui duas subárvores Tb e Tc, onde:

Tb= {B} e Tc= {C, D, E, …}

A subárvore Tc possui 3 subárvores Td, Tf e Te, onde:

TD= {D, G, H}
TF= {F, I}
TE = {E}

As subárvores TB, TE, TG, TH e TI possuem apenas o nó raiz e nenhuma

subárvore.

3.1. Nós filhos, pais, irmãos e avôs:

Seja v, o nó raiz da subárvore Tv e T.

Os nós raízes w1, w2, ..., wj das subárvores de Tv são chamados filhos de v.
v é chamado pai de w1, w2, ..., wj .

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 4
 Estrutura de Dados

Os nós w1, w2, ..., wj são irmãos.

Se z é filho de w1 então w2 é tio de z e v é avô de z.

Ex: Filhos de D: G e H
Filhos de A: B e C
Pai de E: C
Irmãos de D: E e F
Avô de H: C

3.2. Nó ancestral, nó descendente, nó ancestral próprio e nó descendente

próprio:

- Se um nó qualquer pertence à subárvore T v, então x é descendente de v e v é

ancestral de x ou antecessor de x.
- Se, neste caso, x é diferente de v então x é descendente próprio de v, e v é
ancestral próprio de x.

OBS: Todos os vértices são descendentes da raiz, inclusive ela mesma.

Ex: descendentes de B: B
descendentes de A: todos os nós, inclusive A
ancestral de G: G, D, C, A
descendentes próprios de D: G e H
ancestrais próprios de B: A

Grau de saída de um nó: é o número de filhos do nó.

Ex: GS(C) = 3
GS(G) = 0
GS(A) = 2
GS(F) = 1

Uma folha é um nó sem filhos, ou seja, sem descendentes próprios.

Folhas = nós terminais

Ex: B, E, G, H, I

Nós não folhas = nós interiores = nós não terminais

Ex: A, C, D, F

Um caminho na árvore T é uma sequência (de pelo menos um nó) v 1, v2, ..., vn de
vértices, tal que vi é pai de vi+1, i = 1, ..., k-1.

Ex: o caminho de A até G = ACDG

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 5
 Estrutura de Dados

o caminho de C até H = CDH

o caminho de D até A = não existe

OBS.: Existe sempre um único caminho entre um vértice e qualquer um dos seus
descendentes.

Nível de um vértice v qualquer é o número de nós do único caminho da raiz até v.

Ex: nível de H: 4
nível de A: 1
nível de C: 2

Altura ou profundidade de um vértice v qualquer é o número de nós do maior caminho

de v a um descendente.

Ex: altura de D: 2
altura de A: 4
altura de qualquer folha: 1

OBS.: A altura da raiz é a altura da árvore.

4. Árvores m-árias (m >= 2)

Definição: Uma árvore m-ária é um conjunto de vértices T, tais que:

i. ou T é vazio e a árvore é dita vazia;
ii. ou então r ϵ T (raiz) e os demais vértices são
divididos em m conjuntos disjuntos, possivelmente vazios,
denominados 1a., 2a., 3a., ..., ma subárvore de r, cada uma
sendo uma árvore m-ária.

OBS.: Todas as definições vistas anteriormente valem para árvores m-árias.

Definição: Uma árvore é estritamente m-ária se cada vértice tem zero ou m filhos.
Neste caso, um nó com m filhos é chamado cheio e quando não é cheio é folha.

Ex: uma árvore m-ária (m = 3)

A

B C

E F
D

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 6
 Estrutura de Dados

Ex: Uma árvore estritamente m-ária (m = 2)

B C

D E F G

H I

Definição: Uma árvore m-ária é cheia quando todos os nós não cheios estão no último
nível.

Ex: Uma árvore m-ária cheia (m = 2)

B C

D E F G

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 7
 Estrutura de Dados

5. Árvores Binárias

Definição: Uma árvore binária T é um conjunto finito de nós tal que:

i. T=0 é dita uma árvore vazia ou
ii. T consiste de uma raiz r e duas subárvores binárias
separadas, denominadas “subárvore a esquerda de r” e
“subárvore a direita de r”.

Numa árvore binária não existe nó com grau superior a dois.

Ex: A

B C

D E F G

H I

O número máximo de nós no nível k de uma árvore binária é 2k-1, k≥1.

O número máximo de nós numa árvore binária de profundidade n é 2n-1, n≥1.

5.1. Representação de Árvores Binárias

Considere a seguinte estrutura:

struct tree{
struct tree *esq;
int chave;
struct tree *dir;
};

Referência Informação Referência para o filho da

para o filho direita
da esquerda

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 8
 Estrutura de Dados

Ex:

raiz

B C

D E F

G H

5.2 Percursos em Árvores Binárias

Processo sistemático de exploração que consiste em visitar cada nó da

árvore exatamente uma vez.
Para acessarmos os elementos de uma árvore binária devemos percorrer
os nós através das referências que temos para os seus filhos esquerdo e direito.
Existem três ordens de caminhamento nas árvores binárias:

1) Caminhamento Central (inorder)

a) Percorre a subárvore da esquerda;
b) Visita a raiz;
c) Percorre a subárvore da direita.
2) Caminhamento Pré-ordem (preorder)
a) Visita a raiz;
b) Percorre a subárvore da esquerda;
c) Percorre a subárvore da direita.
3) Caminhamento Pós-ordem (postorder)
a) Percorre a subárvore da esquerda;

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 9
 Estrutura de Dados

b) Percorre a subárvore da direita;

c) Visita a raiz.

Exemplos: Percorra as árvores abaixo nos três caminhamentos:

a)
40

25 33
C

23 12
E 48
F 67

10 65

35

Inoder:23,25,10, 35, 12, 40, 48, 65, 33, 67.

Preorder:40, 25, 23,12,10, 35,33, 48, 65, 67.
Postorder: 23, 35,10, 12, 25, 65, 48, 67, 33, 40.

b)
8

2 11
C

1 E
5 F
9 12

10
3 6 10

4 7

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 10
 Estrutura de Dados

Em C:

1. Inorder

void inorder(struct tree *raiz)

{
if(raiz != NULL)
{
inorder(raiz -> esq);
printf(“%d \t”, raiz -> chave);
inorder(raiz -> dir);
}
}

2. Preorder

void preorder(struct tree *raiz)

{
if(raiz != NULL)
{
printf(“%d \t”, raiz -> chave);
preorder(raiz -> esq);
preorder(raiz -> dir);
}
}

3. Postorder

void postorder(struct tree *raiz)

{
if(raiz != NULL)
{
postorder(raiz -> esq);
postorder(raiz -> dir);
printf(“%d \t”, raiz -> chave);
}
}

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 11
 Estrutura de Dados

Exercício: Faça a árvore de recursão das três funções de caminhamentos e imprima as

chaves da árvore abaixo:

raiz
43

23 21

15 18 27

33 9

12

Exemplos de funções recursivas com árvores binárias:

1) Função recursiva para contar os nós da árvore.

int contaNos(struct tree *raiz)

{
if(!raiz)
return 0;
return (1+contaNos(raiz->esq)+contaNos(raiz->dir));
}

2) Função recursiva para contar os nós folhas da árvore.

int contaFolhas(struct tree *raiz)

{
if(!raiz)
return 0;
if(!raiz->esq && !raiz->dir)
© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 12
 Estrutura de Dados

return 1;
return (contaFolhas(raiz->esq) + contaFolhas(raiz->dir);
}

3) Função recursiva para contar os nós pais da árvore.

int contaPais(struct tree *raiz)

{
if(!raiz)
return 0;
if(!raiz->esq && !raiz->dir)
return 0;
return (1+contaPais(raiz->esq) + contaPais(raiz->dir));
}

4) Função recursiva para calcular a a altura da árvore.

int altura(struct tree *raiz)

{
int e, d;

if(!raiz)
return 0;
e=1+altura(raiz -> esq);
d=1+altura(raiz -> dir);
return (e >= d ? e : d);
}

5) Função recursiva para somar as chaves da árvore.

int somaChaves(struct tree *raiz)

{
if(!raiz)
return 0;
return(raiz -> chave+somaChaves(raiz -> esq) + somaChaves(raiz
-> dir));

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 13
 Estrutura de Dados

6. Árvores Binárias de Busca (ABB)

Definição: Uma ABB é uma árvore binária que armazena chaves não repetidas. E para
cada nó vale a seguinte propriedade:
i) As chaves situadas na subárvore à esquerda da raiz são menores que a raiz;
ii) As chaves situadas na subárvore à direita da raiz são maiores que a raiz;
iii) As subárvores esquerda e direita também são binárias de busca.
Note que, uma Árvore Binária de Busca pode ser vazia.

Considere a seguinte estrutura:

struct tree{
struct tree *esq;
int chave;
struct tree *dir;
};

Ex:

38

32 51
C

21 35
E 45
F 62

10
33 36 49
25

34 37

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 14
 Estrutura de Dados

Exercício: Monte uma ABB na sequência dada:

65, 73, 90, 80, 60, 40, 20, 70, 30, 50, 35, 45, 55, 75, 77, 25, 15, 63, 85, 27, 88, 92.

Operações:

1. Busca

- Iterativo:

#define TRUE 1
#define FALSE 0

struct tree *busca(struct tree *raiz, int x)

{
int nao_achei=TRUE;

while(raiz && nao_achei)

{
if( x == raiz->chave)
nao_achei=FALSE;
else if(x < raiz->chave)
raiz=raiz->esq;
else
raiz=raiz->dir;
}
if(nao_achei)
return NULL;
else
return raiz;
}

- Recursivo:

struct tree *buscaRec(struct tree *raiz, int x)

{
if(raiz)
{
if(x== raiz -> chave)
return(raiz);

if(x < raiz -> chave)

return(buscaRec(raiz -> esq, x));

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 15
 Estrutura de Dados

if(x > raiz -> chave)

return(buscaRec(raiz -> dir, x));
}
return(NULL);
}

2. Inserção

A chave a ser inserida ficará sempre em uma folha. Não há repetição de chaves.

- Iterativo:

struct tree *insereABB(struct tree *raiz, int valor)

{
struct tree *p,*t;
int achou;
p=(struct tree *) malloc( sizeof(struct tree));
p->chave=valor;
p->dir=p->esq=NULL;
if(!raiz)
raiz=p;
else{
achou=FALSE;
t=raiz;
while(!achou)
{
if(valor< t -> chave)
{
if(t->esq==NULL)
{
t->esq=p;
achou=TRUE;
}
else
t=t -> esq;
}
else if(t->dir==NULL)
{
t->dir=p;
achou=TRUE;
}
else
t=t->dir;
}
}
return raiz;
}

- Recursivo: (fazer)
© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 16
 Estrutura de Dados

3. Remoção

Na remoção de um nó numa ABB devemos nos certificar da manutenção da sua

ordenação. Podemos dividir em três casos:

1) Nós sem filhos (folhas)

Devemos ajustar a referência do pai correspondente e, em seguida remover o nó
da árvore.
Ex: Remover o nó que contém a chave 17:
20
20
15 25
15 25

12 34
12 17 34

2) Nós com um único filho

Devemos ajustar a referência do pai correspondente ao nó, fazendo-o apontar
para o filho de nó que vai ser removido.
Ex: Remover o nó que contém a chave 15:

20
20
12 25
15 25

12 23 34 23 34

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 17
 Estrutura de Dados

3) Nós com dois filhos

Devemos substituir o nó a ser removido pelo seu sucessor imediato.
Sucessor imediato é o descendente mais a esquerda a partir da sua subárvore da
direita.
Ex: Remover o nó que contém a chave 20:

23
20

12 25
12 25

18 23 34 10 18 34
10

- Iterativo:

void removeABB(struct tree *raiz, int x)

{
struct tree *p, *q, *rp, *f, *s;
q=NULL;
p=raiz;
while(p && x!=p -> chave)
{
q=p;
p=(x<p->chave) ? P -> esq : p->dir;
}
if(!p)
return;
if(!p->esq)
rp=p->dir;
else{
if(!p->dir)
rp=p->esq;
else{
f=p;
rp=p->dir;
s=rp->esq;
while(s)
{
f=rp;
rp=s;
s=r->esq;
© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 18
 Estrutura de Dados

}
if(f!=p)
{
f->esq=rp->dir;
rp->dir=p->dir;
}
rp->esq=p->esq;
}
}
if(!q)
raiz=rp;
else
(p==q->esq) ? (q->esq=np):(q->dir=rp);
free(p);
}

Exercício: Faça um programa que contenha uma estrutura de ABB que armazena
chaves inteiras e mostre o seguinte menu de opções:
1- Inserir uma chave na árvore
2- Buscar uma chave na árvore
3- Percorrer a árvore (usuário deve escolher um dos caminhamentos)
4- Remover um nó da árvore
5- Contar os nós da árvore
6- Contar os nós folhas da árvore
7- Contar os nós pais da árvore
8- Calcular a altura da árvore
9- Mostrar o maior elemento da árvore
10- Mostrar o menor elemento da árvore
11- Mostrar a soma das chaves na árvore
12- Sair
- Crie funções recursivas para para opção do menu, exceto para as opções 4 e 12.
- Na opção 2, a chave deve ser lida via teclado e mostrar uma mensagem se achou ou
não achou.
- Na opção 3, mostre um menu com as três opções de caminhamento para o usuário.
- Na opção 4, a chave deve ser lida via teclado e fazer a remoção caso a chave exista na
árvore.

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 19
 Estrutura de Dados

7. Árvores Balanceadas

Árvores AVL

Adelson-Velskii e Landis introduziram a estrutura de ABB que é equilibrada

(balanceada) com respeito às alturas das subárvores.

Definição: A árvore vazia é de altura equilibrada. Seja T uma ABB não vazia com T e e
Td como subárvores esquerda e direita, então T terá altura equilibrada se:
i) Te e Td forem de altura equilibrada:
ii) he-hd ≤1, onde he e hd são as alturas Te e Td, respectivamente.

Definição: O fator de equilibrio de um nó T numa ABB é definido como h e - hd. Para

quaquer nó T numa AVL, o fator equilíbrio é -1, 0 ou +1.

Definição: Uma árvore AVL é uma ABB que é vazia ou cuja diferença de pesos entre
as alturas das subárvores esquerda e direita é no máximo igual a 1, e as subárvores
esquerda e direita, por sua vez, também são árvores AVL.

Exemplos:
25 2-3=-1

15 0-1=-1 30 0-2=-2

19 0-0=0 35 1-0=+1

32 0-0=0
Não é AVL

28 2-2=0

20 0-1=-1 30 0-1=-1

26 0-0=0 35 0-0=0

É AVL

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 20
 Estrutura de Dados

Rotações em árvore AVL

Uma rotação reequilibra parte de uma AVL reorganizando os nós, porém,

preservando as propriedades, mantendo a árvore como uma ABB.
Após a rotação, os fatores de equilíibrio de todos os nós na subárvore balanceada
são -1, 0 ou +1.

Rotação Direita: O desequilíbrio está na esquerda do ancestral (nó desequilibrado).

void rotacaoDireita(struct tree *raiz)

{
struct tree *p, *q, *h;
p=raiz;
q=p->esq;
h=q->dir;
q->dir=p;
p->esq=h;
raiz=q;
}

Rotação Esquerda: O desequilíbrio está na direita do ancestral (nó desequilibrado).

void rotacaoEsquerda(struct tree *raiz)

{
struct tree *p,*q,*h;
p=raiz;
q=p->dir;
h=q->esq;
q->esq=p;
p->dir=h;
raiz=q;
}

As rotações são caracterizadas pelo ancestral mais próximo do nó inserido x cujo fator
de equilíbrio passa a ser -2 ou +2. Assim, temos as seguintes rotações:

1) Rotação Simples Esquerda-Esquerda (EE): novo nó x inserido na subárvore

esquerda da subárvore esquerda do ancestra.

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 21
 Estrutura de Dados

2) Rotação Simples Direita-Direita (DD): novo nó x inserido na subárvore direita da

subárvore direita do ancestral.

3) Rotação Dupla Esquerda-Direita (ED): novo nó x inserido na subárvore direita da

subárvore esquerda do ancestral.

4) Rotação Dupla Direita-Esquerda (DE): novo nó x inserido na subárvore esquerda da

subárvore direita do ancestral.

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 22
 Estrutura de Dados

8. Árvores B

As árvores B foram definidas originalmente em 1972, por Bayer. Atualmente

quase todos os gerenciadores de banco de dados têm internamente tais árvores para
armazenar chaves de registros, devido a sua eficiência nas operações básicas (busca,
inserção e remoção). As árvores B são largamente utilizadas como forma de
armazenamento em memória secundária.
São árvores permanentemente balanceadas, desenvolvidas para otimizar o acesso
a armazenamento secundário.
Os nós da árvore B podem ter muitos filhos. Esse fator de ramificação é
determinante para reduzir o número de acessos a disco.

Definição: Seja d um número natural. Uma árvore B de ordem d é uma árvore ordenada
que é vazia ou satisfaz as seguintes condições:

i) A raiz é uma folha ou tem no mínimo dois filhos;

ii) Cada nó diferente da raiz e das folhas possui no mínimo d+1 filhos;
iii) Cada nó tem no máximo 2d+1 filhos;
iv) Todas as folhas estão situadas no mesmo nível (balanceamento);
v) Um nó numa árvore B é chamado página. Uma página armazena então
diversas chaves;
vi) A raiz (página) tem no mínimo 1 chave e no máximo 2d chaves;
vii) Os demais nós (páginas) tem, no mínimo d chaves e no máximo 2d chaves;
viii) Se x1, ..., xm são chaves e T0 , T1 , ..., Tm são as subárvores de um nó então

Ex:

As chaves em T0 <x1 < as chaves em T1 <x2 <...< as chaves em Tm-1 < Tm.

Ex: Uma árvore B de ordem d=2 com três níveis:

Note que todas as páginas contém 2, 3 ou 4 registros, exceto a raiz que pode conter
apenas um registro.

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 23
 Estrutura de Dados

Os registros aparecem em ordem crescente da esquerda para direita, o que

representa um esquema normal de organização de árvore de busca.

Operações:

1) Busca

O método empregado na busca de uma determinada chave é similar ao utilizado

na busca em uma ABB.

2) Inserção

A inserção é feita sempre na folha. Para inserir uma chave x numa árvore B de
ordem d:

1) É preciso realizar a busca de x pois não pode haver repetição de elementos;

2) Se a folha tem menos de 2d chaves, x é inserida mantendo a ordenação entre as
chaves do nó (página);
3) Se a folha tem exatamente 2d chaves, deve-se fazer a cisão, ou seja, reorganização
das páginas, que pode ser propagada.

O que é cisão?

Consiste em fazer a redistribuição das chaves, caso não haja espaço para a
inserção em um nó já existente.
O processo consiste em criar um novo nó adjacente (vizinho) ao nó que pode
abrigar a chave a ser inserida e fazer a redistribuição simétrica das entradas entre os
dois nós.

Ex: Inserir as chaves numa árvore B de ordem d=2, inicialmente vazia:

150, 250, 300, 450, 400,

15, 55, 260,
220, 270, 280,
230, 240, 245,
10, 75, 65.

Exercício:

1) Monte uma árvore B de ordem d=2, passo a passo, na sequência dada:

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 11, 12,
13, 26, 27, 29, 30.

2) Use a mesma sequência para montar uma árvore B de ordem d=3, passo a passo.

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 24
 Estrutura de Dados

3) Remoção

Seja x a chave a ser removida de uma árvore B de ordem d. Então, a princípio

há dois casos a seguir:
1) x está situada numa folha;
2) x não está numa folha. Neste caso, x será substituída pela chave y
imediatamente maior.

O caso 1 pode ser dividido em duas possibilidades:

a) Se a folha tem mais de d chaves então x é removida sem problemas;
b) Se a folha tem exatamente d chaves, duas estratégias podem ser
aplicadas:
-Concatenação ou
- Redistribuição

- Concatenação

Duas páginas P e Q são chamadas irmãs adjacentes se tem o mesmo pai W e são
referenciadas por dois apontadores adjacentes de W.
P e Q podem ser concatenadas se juntas possuem menos de 2d chaves (no
máximo 2d – 1 chaves).
A concatenação, portanto, vai agrupar as entradas das duas páginas em uma só.
Para que isto ocorra, no nó pai W deixa de existir uma entrada, justamente a da chave
que se encontra entre os apontadores para as irmãs adjacentes P e Q. Essa chave passa a
fazer parte do nó concatenado. Como a soma do número de chaves de P e Q era menor
que 2d, a nova página tem no máximo 2d chaves.
A concatenação pode se propagar até a raiz da árvore, se necessário. Se atingir a
raiz da árvore, provocará a diminuição da altura da árvore.

Ex:

- Redistribuição

É aplicável quando um dos irmãos imediato (à esquerda ou à direita) possui mais

de d chaves. Ou seja, quando uma página e sua irmã adjacente possuem em conjunto 2d
chaves ou mais. Dessa forma as páginas podem ser distribuídas.

Como será a redistribuição?

Primeiro concatenam-se as páginas, o que resulta numa página grande. Em

seguida, efetua-
© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 25
 Estrutura de Dados

se uma cisão.
A redistribuição não é propagável.

Ex:

Exercício:

1) Monte uma árvore B de ordem d =2, passo a passo, na sequência dada:

a, b, f, g, k, d, h, m, j, e, s, i, r, x, c, l, n, t, u, p, o.

Logo após a inserção das chaves, faça as seguintes remoções:

a) Remover g;
b) Remover r da árvore resultante da letra a;
c) Remover k da árvore resultante da letra b;
d) Remover a da árvore resultante da letra c;
e) Remover p da árvore resultante da letra d;

2) Insira as chaves abaixo em uma árvore B de ordem d=3, passo a passo:

M, D, H, Q, U, A, B, C, E, F, G, I, J, K, L, N, O, R, S, T, V, W, Z, Y, P, X.

© 2002– 2020 Prof. Dra. Vera Lúcia Prudência dos Santos Caminha – VFI/ICEx/UFF – Volta Redonda-RJ 26