Árvores AVL. Nesta aula será apresentado o ADT árvore AVL que são árvores binárias de altura equilibrada. Algoritmos e Estruturas de Dados I

Transcrição

1 Árvores AVL Nesta aula será apresentado o ADT árvore AVL que são árvores binárias de altura equilibrada Algoritmos e Estruturas de Dados I José Augusto Baranauskas Departamento de Física e Matemática FFCLRP-USP augusto@usp.br

2 Introdução Árvores de altura balanceada ou de altura equilibrada foram introduzidas em 1962 por Adelson-Velskii e Landis, também conhecidas como árvores AVL Devido ao balanceamento da árvore, as operações de busca, inserção e remoção em uma árvore com n elementos podem ser efetuadas em O(log 2 n), mesmo no pior caso Um teorema provado por Adelson-Velskii e Landis garante que a árvore balanceada nunca será 45% mais alta que a correspondente árvore perfeitamente balanceada, independentemente do número de nós existentes

3 Árvore AVL Uma árvore AVL é definida como: Uma árvore vazia é uma árvore AVL Sendo T uma árvore binária de busca cujas subárvores esquerda e direita são L e R, respectivamente, T será uma árvore AVL contanto que: L e R são árvores AVL h L h R 1, onde h L e h R são as alturas das subárvores L e R, respectivamente A definição de uma árvore binária de altura equilibrada (AVL) requer que cada subárvore seja também de altura equilibrada

4 Fator de Balanceamento O fator de balanceamento ou fator de equilíbrio de um nó T em uma árvore binária é definido como sendo h L h R onde h L e h R são as alturas das subárvores esquerda e direita de T, respectivamente Para qualquer nó T numa árvore AVL, o fator de balanceamento assume o valor, ou O fator de balanceamento de uma folha é zero

5 Fator de Balanceamento

6 Fator de Balanceamento Fator= indica que as alturas das subárvores esquerda e direita são iguais

7 Fator de Balanceamento Fator= indica que a altura da subárvore esquerda é maior que da direita

8 Fator de Balanceamento Fator= 1 indica que a altura da subárvore esquerda é menor que da direita

9 Inserção Maio Depois da inserção Maio Depois do rebalanceamento Sem necessidade de rebalanceamento

10 Inserção Março Depois da inserção Depois do rebalanceamento Maio Sem necessidade de rebalanceamento Março

11 Inserção Novembro Depois da inserção Depois do rebalanceamento -2 Maio Março RR A = -2 B = Maio Março Novembro Novembro

12 Inserção Agosto Depois da inserção Depois do rebalanceamento Março Sem necessidade de rebalanceamento Maio Novembro Agosto

13 Inserção Abril Depois da inserção Depois do rebalanceamento +2 Março LL A = +2 B = Março +2 Maio Novembro Agosto Novembro Agosto Abril Maio Abril

14 Inserção Janeiro Depois da inserção Depois do rebalanceamento +2 Março LR A = +2 B = Maio Agosto Novembro Agosto Março Abril Maio Abril Janeiro Novembro Janeiro

15 Inserção Dezembro Depois da inserção Depois do rebalanceamento Maio Sem necessidade de rebalanceamento Agosto Março Abril Janeiro Novembro Dezembro

16 Inserção Julho Depois da inserção Depois do rebalanceamento Maio Sem necessidade de rebalanceamento Agosto Março Abril Janeiro Novembro Dezembro Julho

17 Inserção Fevereiro Depois da inserção Depois do rebalanceamento +2 Maio RL A = -2 B = Maio -2 Agosto Março Dezembro Março Abril Janeiro Novembro Agosto Janeiro Novembro Dezembro Julho Abril Fevereiro Julho Fevereiro

18 Inserção Junho Depois da inserção Depois do rebalanceamento Dez +2 Maio Mar LR A = +2 B = Dez Jan Maio Ago Jan Nov Ago Fev Julho Mar Abril Fev Julho Abril Junho Nov Junho

19 Inserção Outubro Depois da inserção Depois do rebalanceamento Dez Jan Maio RR A = -2 B = Dez Jan Maio Ago Fev Julho -2 Mar Ago Fev Julho Nov Abril Junho Nov Abril Junho Mar Out Out

20 Inserção Setembro Depois da inserção Jan Depois do rebalanceamento Sem necessidade de rebalanceamento Dez Maio Ago Fev Julho Nov Abril Junho Mar Out Set

21 Rotações O processo de rebalanceamento é conduzido utilizando 4 tipos de rotações: LL, RR, LR, RL LL e RR são simétricas entre si assim como LR e RL As rotações são caracterizadas pelo ancestral mais próximo A do novo nó inserido Y cujo fator de balanceamento passa a ser +2 ou -2 LL: Y inserido na subárvore esquerda da subárvore esquerda de A LR: Y inserido na subárvore direita da subárvore esquerda de A RR: Y inserido na subárvore direita da subárvore direita de A RL: Y inserido na subárvore esquerda da subárvore direita de A Seja B o filho de A no qual ocorreu a inserção de Y LL (A = +2; B = ) RR (A = -2; B = ) LR (A = +2; B = ) RL (A = -2; B = ) C é o filho de B no qual ocorreu a inserção de Y

22 Rotação LL Subárvore balanceada A Subárvore desbalanceada após inserção +2 A B h+2 B h+2 h h A R A R B L B R B L B R Subárvore rebalanceada B Altura de B L aumenta para h A h+2 h B L B R A R

23 Rotação LL pa A Assumindo pa e pb ponteiros para as subárvores com raízes A e B: pb = pa->leftnode; pa->leftnode = pb->rightnode; pb->rightnode = pa; pa = pb; B A R B L B R

24 Rotação LL pb pa A Assumindo pa e pb ponteiros para as subárvores com raízes A e B: pb = pa->leftnode; pa->leftnode = pb->rightnode; pb->rightnode = pa; pa = pb; B A R B L B R

25 Rotação LL pb pa Assumindo pa e pb ponteiros para as subárvores com raízes A e B: pb = pa->leftnode; pa->leftnode = pb->rightnode; pb->rightnode = pa; pa = pb; B A B L B R A R

26 Rotação LL pb B pa Assumindo pa e pb ponteiros para as subárvores com raízes A e B: pb = pa->leftnode; pa->leftnode = pb->rightnode; pb->rightnode = pa; pa = pb; A B L BR A R

27 Rotação LL pb B pa Assumindo pa e pb ponteiros para as subárvores com raízes A e B: pb = pa->leftnode; pa->leftnode = pb->rightnode; pb->rightnode = pa; pa = pb; A B L BR A R

28 Rotação RR Subárvore balanceada A Subárvore desbalanceada após inserção -2 A B h+2 B h+2 h h A L A L B L B R B L B R Subárvore rebalanceada B Altura de B R aumenta para h A h+2 h B R A L B L

29 Rotação RR A pa Assumindo pa e pb ponteiros para as subárvores com raízes A e B: pb = pa->rightnode; pa->rightnode = pb->leftnode; pb->leftnode = pa; pa = pb; B A L B L B R

30 Rotação RR A pa pb Assumindo pa e pb ponteiros para as subárvores com raízes A e B: pb = pa->rightnode; pa->rightnode = pb->leftnode; pb->leftnode = pa; pa = pb; B A L B L B R

31 Rotação RR pa pb Assumindo pa e pb ponteiros para as subárvores com raízes A e B: pb = pa->rightnode; pa->rightnode = pb->leftnode; pb->leftnode = pa; pa = pb; A B A L B L B R

32 Rotação RR pa B pb Assumindo pa e pb ponteiros para as subárvores com raízes A e B: pb = pa->rightnode; pa->rightnode = pb->leftnode; pb->leftnode = pa; pa = pb; A B R A L B L

33 Rotação RR pa B pb Assumindo pa e pb ponteiros para as subárvores com raízes A e B: pb = pa->rightnode; pa->rightnode = pb->leftnode; pb->leftnode = pa; pa = pb; A B R A L B L

34 Rotação LR(a) Subárvore balanceada A Subárvore desbalanceada após inserção +2 A B B C Subárvore rebalanceada C B A

35 Rotação LR(b) Subárvore balanceada A Subárvore desbalanceada após inserção +2 A h B L B C L C CR h A R h h+2 h B L B C L C CR A R h h+2 Subárvore rebalanceada C B A h+2 h B L C L C R A R

36 Rotação LR(c) Subárvore balanceada A Subárvore desbalanceada após inserção +2 A h B L B C L C CR h A R h h+2 h B L B C L C CR A R h h+2 Subárvore rebalanceada C B A h+2 h B L C L C R A R

37 Rotação LR B pa C A Assumindo pa, pb e pc ponteiros para as subárvores com raízes A, B e C: pb = pa->leftnode; pc = pb->rightnode; pb->rightnode = pc->leftnode; pc->leftnode = pb; pa->leftnode = pc->rightnode; pc->rightnode = pa; pa = pc; A R B L C L C R

38 Rotação LR pb B pa C A Assumindo pa, pb e pc ponteiros para as subárvores com raízes A, B e C: pb = pa->leftnode; pc = pb->rightnode; pb->rightnode = pc->leftnode; pc->leftnode = pb; pa->leftnode = pc->rightnode; pc->rightnode = pa; pa = pc; A R B L C L C R

39 Rotação LR pb B pa C A pc Assumindo pa, pb e pc ponteiros para as subárvores com raízes A, B e C: pb = pa->leftnode; pc = pb->rightnode; pb->rightnode = pc->leftnode; pc->leftnode = pb; pa->leftnode = pc->rightnode; pc->rightnode = pa; pa = pc; A R B L C L C R

40 Rotação LR pb pa A Assumindo pa, pb e pc ponteiros para as subárvores com raízes A, B e C: pb = pa->leftnode; pc = pb->rightnode; pc pb->rightnode = pc->leftnode; pc->leftnode = pb; B pa->leftnode = pc->rightnode; C pc->rightnode = pa; pa = pc; A R B L C L C R

41 Rotação LR pb C pc pa A Assumindo pa, pb e pc ponteiros para as subárvores com raízes A, B e C: pb = pa->leftnode; pc = pb->rightnode; pb->rightnode = pc->leftnode; pc->leftnode = pb; B pa->leftnode = pc->rightnode; pc->rightnode = pa; pa = pc; A R B L C L C R

42 Rotação LR pc pb C pa Assumindo pa, pb e pc ponteiros para as subárvores com raízes A, B e C: pb = pa->leftnode; pc = pb->rightnode; pb->rightnode = pc->leftnode; B A pc->leftnode = pb; pa->leftnode = pc->rightnode; pc->rightnode = pa; pa = pc; B L C L C R A R

43 Rotação LR pc pb C pa Assumindo pa, pb e pc ponteiros para as subárvores com raízes A, B e C: pb = pa->leftnode; pc = pb->rightnode; pb->rightnode = pc->leftnode; B A pc->leftnode = pb; pa->leftnode = pc->rightnode; pc->rightnode = pa; pa = pc; B L C L C R A R

44 Rotação LR pb C pc pa Assumindo pa, pb e pc ponteiros para as subárvores com raízes A, B e C: pb = pa->leftnode; pc = pb->rightnode; pb->rightnode = pc->leftnode; B A pc->leftnode = pb; pa->leftnode = pc->rightnode; pc->rightnode = pa; pa = pc; B L C L C R A R

45 Rotação RL(a) Subárvore balanceada A Subárvore desbalanceada após inserção -2 A B B C Subárvore rebalanceada C A B

46 Rotação RL(b) Subárvore balanceada A Subárvore desbalanceada após inserção -2 A h+2 h A L h CL C C R B B R h h+2 h A L CL C C R B B R h Subárvore rebalanceada C A B h+2 A L C L C R B R h

47 Rotação RL(c) Subárvore balanceada A Subárvore desbalanceada após inserção -2 A h+2 h A L h CL C C R B B R h h+2 h A L CL C C R B B R h Subárvore rebalanceada C A B h+2 A L C L C R B R h

48 Inserções Inserir x=7 4 5

49 Inserções Inserido x=7 A inserção produz uma árvore desbalanceada

50 Inserções Inserido x=7 A inserção produz uma árvore desbalanceada, cujo balanceamento envolve uma rotação RR 4 5 7

51 Inserções Inserir x=

52 Inserções Inserido x=

53 Inserções Inserido x=2 Inserir x=

54 Inserções Inserido x=2 Inserido x=1 Ocorre desbalanceamento da subárvore de raiz

55 Inserções Inserido x=2 Inserido x=1 Ocorre desbalanceamento da subárvore de raiz 4, que é corrigido por uma rotação LL

56 Inserções Inserir x=

57 Inserções Inserido x=3 Ocorre desbalanceamento da subárvore de raiz

58 Inserções Inserido x=3 Ocorre desbalanceamento da subárvore de raiz 5, que é corrigido por uma rotação LR

59 Inserções Inserir x=

60 Inserções Inserido x=6 Ocorre desbalanceamento da subárvore de raiz

61 Inserções Inserido x=6 Ocorre desbalanceamento da subárvore de raiz 5, que é corrigido por uma rotação RL

62 Representação Vamos representar um nó AVL de forma similar a um nó em uma árvore binária de busca, contendo um campo adicional bal para manter o fator de balanceamento do nó: struct TreeNode { int Entry; // chave int count; // contador int bal; //,, TreeNode *LeftNode, *RightNode; //subárvores }; typedef TreeNode *TreePointer;

63 Busca com Inserção Para realizar as operações necessárias em cada nó isolado é descrito a seguir um algoritmo recursivo Por ser recursivo, é simples a incorporação de uma operação adicional a ser executada no caminho de volta ao longo do trajeto de busca A cada passo é necessário descobrir e informar se a altura da subárvore em que foi feita a inserção cresceu ou não Para tanto, foi incluído um parâmetro booleano h, passado por referência (com valor inicial false), que indica que a subárvore cresceu em altura O algoritmo de inserção deve ser chamado com o ponteiro pa como sendo a raiz da árvore (root)

64 Busca com Inserção Suponha que o algoritmo retorne, partindo da subárvore esquerda a um nó p com a indicação que houve um incremento em sua altura Existem três condições relacionadas com as alturas das subárvores antes da inserção h L < h R, p->bal == Após a inserção, o desbalanceamento em p foi equilibrado h L == h R, p->bal == Após a inserção, a altura da árvore é maior à esquerda h L > h R, p->bal == Após a inserção, é necessário fazer o rebalanceamento

65 Busca com Inserção Após uma rotação LL ou RR, os nós A e B passam a ter fator de balanceamento iguais a zero No caso de rotações LR ou RL Os fatores de balanceamento dos nós A e B podem ser recalculados com base no fator de balanceamento do nó C O novo fator de balanceamento do nó C passa a ser zero

66 Busca com Inserção void AVLTree::SearchInsert(int x, TreePointer &pa, bool &h) { TreePointer pb, pc; if(pa == NULL) // inserir { pa = new TreeNode; h = true; pa->entry = x; pa->count = 1; pa->leftnode = pa->rightnode = NULL; pa->bal = ; }

67 Busca com Inserção else if(x < pa->entry) { SearchInsert(x, pa->leftnode, h); if(h) // subárvore esquerda cresceu { switch (pa->bal) { case : pa->bal = ; h = false; break; case : pa->bal = ; break; case : pb = pa->leftnode; if(pb->bal == ) // rotação LL { pa->leftnode = pb->rightnode; pb->rightnode = pa; pa->bal = ; pa = pb; } else // rotação LR { pc = pb->rightnode; pb->rightnode = pc->leftnode; pc->leftnode = pb; pa->leftnode = pc->rightnode; pc->rightnode = pa; if(pc->bal == ) pa->bal = ; else pa->bal = ; if(pc->bal == ) pb->bal = ; else pb->bal = ; pa = pc; } pa->bal = ; h = false; } // switch } }

68 Busca com Inserção else if(x > pa->entry) { SearchInsert(x, pa->rightnode, h); if(h) // subárvore direita cresceu { switch (pa->bal) { case : pa->bal = ; h = false; break; case : pa->bal = ; break; case : pb = pa->rightnode; if(pb->bal == ) // rotação RR { pa->rightnode = pb->leftnode; pb->leftnode = pa; pa->bal = ; pa = pb; } else // rotação RL { pc = pb->leftnode; pb->leftnode = pc->rightnode; pc->rightnode = pb; pa->rightnode = pc->leftnode; } } pc->leftnode = pa; if(pc->bal == ) pa->bal = ; else pa->bal = ; if(pc->bal == ) pb->bal = ; else pb->bal = ; pa = pc; } pa->bal = ; h = false; } // switch

69 Busca com Inserção } else // elemento encontrado pa->count++;

70 Remoção Antes da remoção Depois do rebalanceamento

71 Remoção Depois da remoção Depois do rebalanceamento 5 LL

72 Remoção Antes da remoção Depois do rebalanceamento Obs: foi utilizado o maior elemento da subárvore esquerda do nó sendo removido

73 Remoção Depois da remoção Depois do rebalanceamento 5 Sem necessidade de rebalanceamento Obs: foi utilizado o maior elemento da subárvore esquerda do nó sendo removido

74 Remoção Antes da remoção Depois do rebalanceamento

75 Remoção Depois da remoção Depois do rebalanceamento 5 RR

76 Remoção Antes da remoção Depois do rebalanceamento

77 Remoção Depois da remoção Depois do rebalanceamento 3 Sem necessidade de rebalanceamento

78 Remoção Antes da remoção Depois do rebalanceamento

79 Remoção Depois da remoção Depois do rebalanceamento -2 3 RL

80 Remoção Antes da remoção Depois do rebalanceamento

81 Remoção Depois da remoção Depois do rebalanceamento 7 Sem necessidade de rebalanceamento

82 Remoção Antes da remoção Depois do rebalanceamento

83 Remoção Depois da remoção Depois do rebalanceamento -2 3 RR

84 Remoção Antes da remoção Depois do rebalanceamento

85 Remoção Antes da remoção Depois do rebalanceamento +2 1 LR

86 Remoção A remoção em árvores AVL é similar à remoção em uma árvore binária de busca Todavia, é preciso verificar o balanceamento e, se necessário, aplicar algumas das rotações Nos algoritmos, foi acrescentado um parâmetro h, passado por referência (cujo valor inicial deve ser false) indicando que a altura da subárvore foi reduzida O método DelMin procura, na subárvore direita, pelo menor valor e só é chamando quando o nó com chave x possui as duas subárvores O rebalanceamento somente é efetuado se h é true O algoritmo de remoção deve ser chamado com o ponteiro p como sendo a raiz da árvore (root)

87 Remoção void AVLTree::Delete(int x, TreePointer &p, bool &h) { TreePointer q; if(p == NULL) { cout << "Elemento inexistente"; abort(); } if(x < p->entry) { Delete(x,p->LeftNode,h); if(h) balancel(p,h); } else if(x > p->entry) { Delete(x,p->RightNode,h); if(h) balancer(p,h); } else // remover p-> } { q = p; if(q->rightnode == NULL) { p = q->leftnode; h = true; } else if(q->leftnode == NULL) { p = q->rightnode; h = true; } else { DelMin(q,q->RightNode,h); if(h) balancer(p,h); } delete q; }

88 Remoção void AVLTree::DelMin(TreePointer &q, TreePointer &r, bool &h) { if(r->leftnode!= NULL) { DelMin(q, r->leftnode, h); if(h) balancel(r,h); } else { q->entry = r->entry; q->count = r->count; q = r; r = r->rightnode; h = true; } }

89 Remoção void AVLTree::balanceL(TreePointer &pa, bool &h) { TreePointer pb, pc; int balb, balc; // subarvore esquerda encolheu switch(pa->bal) { case : pa->bal = ; break; case : pa->bal = ; h = false; break; case : pb = pa->rightnode; balb = pb->bal; if(balb <= ) // rotacao RR { pa->rightnode = pb->leftnode; pb->leftnode = pa; if(balb == ) { pa->bal = ; pb->bal = ; h = false; } else { pa->bal = ; pb->bal = ; } pa = pb; } else // rotacao RL { pc = pb->leftnode; balc = pc->bal; pb->leftnode = pc->rightnode; pc->rightnode = pb; pa->rightnode = pc->leftnode; pc->leftnode = pa; if(balc==) pa->bal=; else pa->bal=; if(balc==) pb->bal=; else pb->bal=; pa = pc; pc->bal = ; } } } void AVLTree::balanceR(TreePointer &pa, bool &h) { TreePointer pb, pc; int balb, balc; // subarvore direita encolheu switch(pa->bal) { case : pa->bal = ; break; case : pa->bal = ; h = false; break; case : pb = pa->leftnode; balb = pb->bal; if(balb >= ) // rotacao LL { pa->leftnode = pb->rightnode; pb->rightnode = pa; if(balb == ) { pa->bal = ; pb->bal = ; h = false; } else { pa->bal = ; pb->bal = ; } pa = pb; } else // rotacao LR { pc = pb->rightnode; balc = pc->bal; pb->rightnode = pc->leftnode; pc->leftnode = pb; pa->leftnode = pc->rightnode; pc->rightnode = pa; if(balc==) pa->bal=; else pa->bal=; if(balc==) pb->bal=; else pb->bal=; pa = pc; pc->bal = ; } } }

90 Resumo Há um custo adicional para manter uma árvore balanceada, mesmo assim garantindo O(log 2 n), mesmo no pior caso, para todas as operações Em testes empíricos Uma rotação é necessária a cada duas inserções Uma rotação é necessária a cada cinco remoções A remoção em árvore balanceada é tão simples (ou tão complexa) quanto a inserção

91 Slides baseados em: Horowitz, E. & Sahni, S.; Fundamentos de Estruturas de Dados, Editora Campus, Wirth, N.; Algoritmos e Estruturas de Dados, Prentice/Hall do Brasil, Material elaborado por José Augusto Baranauskas Elaboração inicial 26; Revisão atual 27