Splaying Tree (Árvore espalhada) Estrutura de Dados II Jairo Francisco de Souza

Transcrição

1 Splaying Tree (Árvore espalhada) Estrutura de Dados II Jairo Francisco de Souza

2 Introdução Inventada por Adelson Velskii e Landis Também chamada de Árvores Auto-Ajustadas ou Árvore de Afunilamento. É um tipo de Árvore Binária de Pesquisa (BST) máximo 2 filhos: TE e TD; todos nós à esquerda contem subárvores com valores menores ao nó raiz da subárvore; todos nós à direita contem valores maiores ao nó raiz da subárvore;

3 Introdução Árvores mais simples que AVL: não forçam o equilíbrio; não mantém informação de altura. É uma árvore auto-ajustável, alterações tendem ao equilíbrio. É utilizada para aplicações específicas, onde se realizam uma seqüência de operações em um universo ordenado. Possui três operações básicas: pesquisa, inserção e remoção. Em todas operações a árvore faz SPLAY.

4 Introdução Permite pior caso para uma só operação O(n) Garante pior caso amortizado O(logn) Uma sequência qualquer de m operações demora, no pior caso O(m log n) reestruturar a árvore para impedir repetição de operações O(n)

5 Espalhamento O que é fazer SPLAY? É trazer um elemento X para a raiz da árvore (BTT- Bring To Top), utilizando sucessivas rotações e tantas quanto necessárias. Objetivos: Minimizar o número de acessos para achar a chave requerida. Otimizar a eficiência das operações, através da freqüência com que cada nó é acessado, mantendo estes nós na parte superior da árvore.

6 Espalhamento Torna mais acessível o que é mais usado; Ajusta a estrutura da árvore à frequência de acesso aos dados; Junto à raiz estão os elementos mais usados mais recentes Os elementos mais inativos ficam mais longe da raiz; O recurso é implementado por meio de rotações nos nós.

7 Rotações Rotação Simples: Zig direita Zig esquerda Rotação Dupla: Zig-zig direita; Zig-zig esquerda; Zig-zag esquerda e direita. Mesma que a AVL

8 Rotação Zig Nesta rotação, o filho direito do elemento y, ficará o filho esquerdo do elemento x, que era pai de y. É a rotação de um nó sobre seu pai, permanecendo a árvore com a mesma altura.

9 Rotação Zig-Zig Para fazer o zig-zig de x, primeiro temos que fazer o zig do pai de x (que é y). Depois, fazemos o zig de x. Conclusão: no fundo é feito zig (y) e zig (x), respectivamente.

10 Rotação Zig-Zag Ao contrário de ZIG-ZIG, primeiro devemos fazer o ZIG de X com o pai de X (que é o y). Depois fazer o ZIG de X com avô de X (que é o Z). Conclusão: No fundo corresponde a fazer ZIG (X) e ZIG (X).

11 EXEMPLOS a) ZIG: rotação simples. (b) Zig-zig: duas rotações simples (c) Zig-zag: rotação dupla.

12 Exemplo de Pesquisa(9, A): 1) Pesquisa tipo BST até encontrar o nó 2) Se nó existe então fazer SPLAY do x (neste caso 9). Caso não exista, fazer SPLAY do último nodo não nulo encontrado na busca (elemento menor ou maior, mais próximo de 9. 2) Neste caso, para fazer SPLAY, utilizar o ZIG-ZAG(x). 3) Árvore final com o x na raiz.

13 Exemplo de Pesquisa(x, A): Início Faz percurso BST até encontrar nó. Se existe o elemento x na árvore A Faz SPLAY do elemento x Senão Faz SPLAY do sucessor esquerdo ou direito mais próximo de x Fim

14 Exemplo de Pesquisa raiz. Pesquisar o valor 80 (não existe na árvore): Como a pesquisa parou em 70, é este o elemento que vai para a raiz. Se a primeira árvore não tivesse o nodo com valor 70, a pesquisa pararia em 90 e o valor 90 iria para a

15 Exemplo de Inserção(8, A) 1) SPLAY(8). 2) 7 vai para a raiz (primeiro elemento menor que 8). 3) Inserir 8, 7 ficará o seu filho esquerdo, e 10 o seu filho direito.

16 Exemplo de Inserção(x, A) OBS: Essa abordagem é interessante caso queira garantir que valores próximos a x fiquem perto da raiz. Início Faz SPLAY do elemento x. Como não existe, o elemento menor mais próximo de x, fica na raiz. Agora é só inserir x, que passa a ser a raiz da árvore. Fim

17 Exemplo de Remoção(12, A) 1) Pesquisa tipo BST. 2) SPLAY (12,A). 3) SPLAY (12,A') onde A' é a subárvore esquerda do 12. 4) O elemento menor mais próximo de 12 vai para a raiz e sem filho esquerdo, podemos então remover. 5) Eliminar o 12 e ligar o pai de x (12) com seu filho direito (15).

18 Exemplo de Remoção(x, A) Início Se existe o elemento x na árvore A. Faz SPLAY do elemento x. Faz SPLAY do elemento x, na sua subárvore esquerda. Traz o elemento menor mais próximo de x para a raiz. Remove o x. Senão Faz SPLAY do elemento menor mais próximo de x. Fim

19 Como fazer o espalhamento?! Duas abordagens Bottom-up Top-down

20 Espalhamento bottom-up rotações ascendentes desde o nó x acessado até à raiz se p (pai de x) é a raiz: rotação simples (zig) senão, existe um a (avô de x) e se x é filho direito (esquerdo) de p e p filho direito (esquerdo) de a faz rotação zig-zig Rodar primeiro o pai e avô, depois o filho se x é filho direito (esquerdo) de p e p filho esquerdo (direito ) de a faz rotação zig-zag Rodar pai e filho, depois avô

21 Espalhamento em k1

22 Espalhamento em k1 Fazer uma pesquisa de k1 extrai a respectiva informação e tem como efeito lateral reestruturar a árvore, tornando-a mais equilibrada Não só o nó k1 veio para raiz como os que estavam no seu caminho ficaram mais perto dela

23 Exemplo OBS: Nesse slide, está sendo realizado o splay depois da inserção, somente para ilustração.

24 Análise do exemplo Inserções cada inserção é feita em tempo constante (insere filho à direita da raíz e faz uma rotação) total das n inserções é O(n) a árvore resultante é muito ruim (lista) mas o processo encontra-se "adiantado relativamente a n * O(log n) Acessos acesso ao nó 1 é O(n) (nº de rotações relacionado com distância à raíz) acesso muito ruim que faz reduzir a vantagem acumulada acesso ao nó 2 já é O(n/2) globalmente: calcula-se tempo amortizado Conclusão consegue-se sempre, para as primeiras m operações, manter o tempo amortizado, mesmo no pior caso, abaixo de O(m log n)

25 Exercício Executar a sequência de operações em uma árvore splay tree utilizando a abordagem bottomup: Inserir 40, 30, 15, 50, 45, 13, 80, 71, 20 Remover 50 Remover 30 Remover 13 Inserir 50 Remover 71

26 Espalhamento top-down Método de splay em apenas 1 passagem top-down mantém o custo amortizado não requer espaço adicional para a pilha dos nós no caminho => melhor que bottom-up Operação de Splay vai manter 3 árvores árvore com raiz no nó corrente (X) - árvore do meio árvore da esquerda L: nós menores que X que não estão na SAE de X árvore da direita R: nós maiores que X que não estão na SAD de X Início: L e R vazias e a raiz da árvore em X Splay: realizado de cima para baixo zig, zig-zag e zig-zig definidos como operações entre as 3 árvores passo final reúne a árvore idéia base: à medida que se desce na árvore à procura de um determinado nó K, afastam-se do caminho (descem) os nós encontrados no percurso até K, ao mesmo tempo que se efetuam algumas rotações que tendem a equilibrar a árvore.

27 Espalhamento top-down - zig

28 Espalhamento top-down zigzig

29 Espalhamento top-down zigzag

30 Espalhamento top-down união

31 Exemplo Visitar o nó de valor 19 e passá-lo para a raiz (se o valor não for encontrado é passado para a raiz o último valor visitado na pesquisa do 19)

32 Exemplo passo 1

33 Exemplo passo 2

34 Exemplo passo 3

35 Exemplo passo 4

36 Implementação em Java - splay private BinaryNode splay( Comparable x, BinaryNode t ) { BinaryNode lefttreemax, righttreemin; header.left = header.right = nullnode; lefttreemax = righttreemin = header; nullnode.element = x; for( ; ; ) if (x.compareto( t.element ) < 0) { if(x.compareto( t.left.element ) < 0) t = Rotations.rotateWithLeftChild(t); if( t.left == nullnode ) break; } // Ligar lado direito righttreemin.left = t; righttreemin = t; t = t.left; } else if( x.compareto( t.element ) > 0 ) { if (x.compareto( t.right.element ) > 0) t = Rotations.rotateWithRightChild(t); if( t.right == nullnode ) break; // Ligar lado esquerdo lefttreemax.right = t; lefttreemax = t; t = t.right; } else break; // Unir as arvores lefttreemax.right = t.left; righttreemin.left = t.right; t.left = header.right; t.right = header.left; return t; // nova raiz

37 Implementação em Java - find /** * Pesquisa um item na árvore. x é o item a ser pesquisado. o item encontrado ou null caso o item não seja encontrado */ public Comparable find( Comparable x ) { root = splay( x, root ); if( isempty( ) root.element.compareto( x )!= 0 ) return null; } return root.element;

38 Implementação em Java - insert public void insert( Comparable x ) { } if( newnode == null ) newnode = new BinaryNode( null ); newnode.element = x; if( root == nullnode ) { newnode.left = newnode.right = nullnode; } else } root = newnode; { root = splay( x, root ); if( x.compareto( root.element ) < 0 ) { } } newnode.left = root.left; newnode.right = root; root.left = nullnode; root = newnode; else if( x.compareto( root.element ) > 0 ) { newnode.right = root.right; newnode.left = root; root.right = nullnode; root = newnode; else throw new DuplicateItemException( x.tostring( ) ); newnode = null; // Para que o próximo insert seja uma nova chamada

39 Implementação em Java - remove public void remove( Comparable x ) { BinaryNode newtree; // Se x for encontrado, ele sera a raiz root = splay( x, root ); if( root.element.compareto( x )!= 0 ) throw new ItemNotFoundException( x.tostring( ) ); } if( root.left == nullnode ) newtree = root.right; else { // Encontre o maximo na SAE // Faca splay com o maximo na raiz; e entao ligue ao filho direito newtree = root.left; newtree = splay( x, newtree ); newtree.right = root.right; } root = newtree;

40 Exercício Executar a sequência de operações em uma árvore splay tree utilizando a abordagem topdown: Inserir 40, 30, 15, 50, 45, 13, 80, 71, 20 Remover 50 Remover 30 Remover 13 Inserir 50 Remover 71

41 Aplicação Consultas bancárias Ao fazer uma consulta, o registro de um cliente será levado para o topo da árvore, diminuindo o tempo de acesso para as próximas consultas. Assim, clientes que fazem consultas freqüentemente, terão acesso mais rápido. Os registros de clientes que não utilizam estes serviços, por sua vez, ficarão nos níveis mais inferiores da árvore. Sistemas de Arquivos Microsoft Windows utiliza na sua indexação de arquivos por árvore Splay.

42 Aplicação Hospital Registro de pacientes recentes vai para a raiz no momento da internação e permanece por algum tempo. Vai afundando, caso não seja acessado. Particularmente útil na implementação de caches. Proxy Squid utiliza árvores Splay para manipular o cache interno de páginas Web.

43 Considerações finais Árvores Splay podem ficar desequilibradas, mas garantem uma complexidade O(log n) ao longo do tempo de utilização (complexidade amortizada). Ajusta a árvore à freqüência de acesso aos dados. Junto à raiz estão os elementos mais usados / mais recentes (mais disponíveis). Os mais inativos ficam mais longe da raiz. É importante notar que em um acesso uniforme, a performance da Árvore Splay será considerada pior que em outro tipo de árvore. Há estudos empíricos, que defendem que, em muitos casos reais, se verifica que 90% dos acessos são feitos apenas à 10% dos elementos.