Árvores. Estruturas de Dados. Prof. Vilson Heck Junior

Transcrição

1 Árvores Estruturas de Dados Prof. Vilson Heck Junior

2 Árvores INTRODUÇÃO

3 Introdução Árvores são estruturas de dados utilizadas para armazenar e recuperar dados de forma rápida e eficiente; Árvores não são lineares, ou seja, os elementos não são dispostos em forma sequencial;

4 Introdução Árvores são amplamente utilizadas e possuem diversas estratégias de implementação; Cada estratégia tem um conjunto específico de algoritmos para armazenamento e recuperação dos dados; Árvores genealógicas são análogas às estruturas de dados árvores.

5 Árvores COMPOSIÇÃO

6 Composição As árvores são compostas por: Nodos/Nós: são os elementos inseridos em uma árvore; Arestas: fazem a ligação entre 2 nodos;

7 Composição O primeiro Nodo de uma árvore é chamado de Raiz; Todos os demais nodos da árvore serão seus descendentes; Nodos que não tenham filhos serão chamados de folhas, ou terminais; Os demais nodos são ditos intermediários, ou às vezes: galhos.

8 Composição As principais propriedades de cada nodo são: Ordem/Grau: Indica o número de filhos que o nodo possui; Nível/Altura/Profundidade: Indica a distância do nodo em relação à raiz; A árvore também possuí valores de ordem e de nível. Ambos os valores serão assumidos com base no maior valor encontrado em qualquer nodo.

9 Árvore: Nível 3 e Ordem 4 Nós / Nodos Arestas A Nível 0 Nó A = Raiz Ordem 2 D G B E Ordem H I F J C Nível Nível 1 Nó B = Galho Ordem 3 Nó C = Folha Ordem 0 Nível 2 Nó D = Folha Ordem 0 Nó E = Galho Ordem 4 Nó F = Folha Ordem 0 Nível 3 Nó G = Folha Ordem 0 Nó H = Folha Ordem 0 Nó I = Folha Ordem 0 Nó J = Folha Ordem 0

10 Árvores OUTRAS PROPRIEDADES

11 Propriedades Qualquer nodo de uma árvore pode ser chamado de raiz para uma sub-árvore; Um Nodo Pai é um nodo conectado diretamente acima de outro nodo; Um Nodo Filho é um nodo conectado diretamente abaixo de outro nodo; Nodos Irmãos compartilham o mesmo nodo pai;

12 Propriedades Nodos Ancestrais são todos os nodos que estão acima de um nodo, com ligação direta ou indireta; Nodos Descendentes são todos os nodos que estão abaixo de um nodo, com ligação direta ou indireta;

13 Árvores EXERCÍCIOS

14 A B C D E F G H I K M N O P R S T U X Y Z W & #

15 Árvores ÁRVORES BINÁRIAS

16 Árvores Binárias Árvores Binárias são árvores com todas as propriedades vistas anteriormente, porém com algumas regras: A Ordem máxima da árvore é 2; Todos os nodos de uma sub-árvore, do filho à direita, serão maiores do que o nodo pai; Todos os nodos de uma sub-árvore, do filho à esquerda, serão menores do que o nodo pai; Geralmente chamadas de Árvores binárias de pesquisa ;

17 Árvores Binárias O número máximo de nodos para cada nível de uma árvore binária é determinada pela equação: total 2 nível

18 Árvore Binária: Nível 4 e Ordem 2 Nós / Nodos Arestas A Nível 0 Nó A = Raiz Ordem 2 B C Nível 1 Nó B = Galho Ordem 2 Nó C = Galho Ordem 2 D H E Ordem I F Nível G Nível 2 Nó D = Folha Ordem 0 Nó E = Galho Ordem 2 Nó F = Folha Ordem 0 Nó G = Folha Ordem 0 Nível 3 Nó H = Galho Ordem 1 Nó I = Folha Ordem 0 J Nível 4 Nó J = Folha Ordem 0

19 Árvores EXEMPLO: ÁRVORE BINÁRIA EM MDA

20 Árvores IMPLEMENTADO ÁRVORES BINÁRIAS

21 Implementando Árvores são implementadas com elementos dinâmicos, assim como nas listas encadeadas; Nas listas, tínhamos apenas um próximo elemento. Nas árvores, cada elemento terá dois próximos : Filho da Esquerda; e Filho da Direita.

22 Implementando public class Nodo { public int numero; //outros atributos //... public Nodo esquerda; public Nodo direita; public Nodo pai; //Opcional }

23 Implementando Para implementar operações em árvores, é necessário percorrer diversos nodos dela; Para inserir um novo elemento, é necessário descer a árvore nível por nível até encontrar a posição adequada ao novo elemento; Para remover um elemento, é necessário descer a árvore até encontrar o elemento a ser removido;

24 Implementando Vale lembrar das regras mais importantes de navegação nas árvores binárias de pesquisa: Elementos menores estarão à esquerda; Elementos maiores estarão à direita.

25 Implementando Inserção: Se a raiz estiver vazia: Insere na raiz. Senão: Navega pela árvore (subindo de nível) comparando o valor a ser inserido com os valores dos nodos visitados; Se Menor Esquerda; e Se Maior Direita; Quando encontrar um nodo sem filho para o lado por onde deveria seguir, insere o novo elemento nesta posição.

26 public static void inserir(nodo novo) { novo.direita = null; novo.esquerda = null; novo.pai = null; if (raiz == null) { raiz = novo; } else { Nodo aux = raiz; while (aux!= null) { if (novo.numero < aux.numero) { if (aux.esquerda == null) { aux.esquerda = novo; break; } aux = aux.esquerda; } } } else { if (aux.direita == null) { aux.direita = novo; break; } aux = aux.direita; } } novo.pai = aux;

27 Implementando Pesquisa: Se a raiz estiver vazia: Não encontrado! Senão: Navega pela árvore (subindo de nível) comparando o valor pesquisado com os valores dos nodos visitados: Igual Encontrado! Menor Desloca à Esquerda; Maior Desloca à Direita; Se percorrer toda a árvore sem encontrar: Não encontrado!

28 Implementando public Nodo pesquisar(int nro) { Nodo aux = raiz; while (aux!= null) { if (aux.numero == nro) { return aux; } else if (nro < aux.numero) { aux = aux.esquerda; } else { aux = aux.direita; } } return null; }

29 Implementando Navegar por todos os Nodos:

30 Implementando Listar Conteúdo da Árvore: A listagem da árvore pode ser feitas de três formas básicas: Em ordem: 1, 2, 3, 4, 6, 8 Pré-ordem: 6, 2, 1, 4, 3, 8 Pós-ordem: 1, 3, 4, 2, 8,

31 Implementando Listar Conteúdo da Árvore: Pode ser implementado com diversas estratégias: Recursividade; Pilha; Busca do subsequente

32 Listar com Recursividade public static void listar(nodo inicio) { if (inicio == null) { return; } listar(inicio.esquerda); System.out.println(inicio.numero); listar(inicio.direita); }

33 Remoção de Nodos: Aux = Pesquisar(Nodo) Se Aux == NULL não encontrado! Senão: Se Aux for raiz: Sem filhos Com um filho Com dois filhos Senão Sem filhos Com um filho Com dois filhos Implementando

34 Remoção de Nodos: Aux = Pesquisar(Nodo) Se Aux == NULL não encontrado! Senão: Se Aux for raiz: Sem filhos Com um filho Com dois filhos Senão Sem filhos Com um filho Com dois filhos Implementando

35 Implementando Remoção de Nodos Raiz sem filhos: Raiz = null;

36 Remoção de Nodos: Aux = Pesquisar(Nodo) Se Aux == NULL não encontrado! Senão: Se Aux for raiz: Sem filhos Com um filho Com dois filhos Senão Sem filhos Com um filho Com dois filhos Implementando

37 Implementando Remoção de Nodos Raiz com um filho: Raiz = Filho Único da Raiz;

38 Remoção de Nodos: Aux = Pesquisar(Nodo) Se Aux == NULL não encontrado! Senão: Se Aux for raiz: Sem filhos Com um filho Com dois filhos Senão Sem filhos Com um filho Com dois filhos Implementando

39 Implementando Remoção de Nodos Raiz com dois filhos: Substituto = Subsequente(Raiz); //Aux Substitui (Raiz pelo Substituto);

40 Remoção de Nodos: Aux = Pesquisar(Nodo) Se Aux == NULL não encontrado! Senão: Se Aux for raiz: Sem filhos Com um filho Com dois filhos Senão Sem filhos Com um filho Com dois filhos Implementando

41 Implementando Remoção de Nodos Não Raiz sem filhos: PaiAux = Aux.Pai; Se (PaiAux.Esquerda == Aux) então PaiAux.Esquerda = null; Senão PaiAux.Direita = null;

42 Remoção de Nodos: Aux = Pesquisar(Nodo) Se Aux == NULL não encontrado! Senão: Se Aux for raiz: Sem filhos Com um filho Com dois filhos Senão Sem filhos Com um filho Com dois filhos Implementando

43 Implementando Remoção de Nodos Não Raiz / 1 filho: PaiAux = Aux.Pai; FilhoAux = Aux.Filho; (esquerda, ou direita) Se (PaiAux.Esquerda == Aux) então PaiAux.Esquerda = FilhoAux; Senão PaiAux.Direita = FilhoAux;

44 Remoção de Nodos: Aux = Pesquisar(Nodo) Se Aux == NULL não encontrado! Senão: Se Aux for raiz: Sem filhos Com um filho Com dois filhos Senão Sem filhos Com um filho Com dois filhos Implementando

45 Implementando Remoção de Nodos Não Raiz / 2 filhos: Substituto = Subsequente(Aux); Substitui (Aux pelo Substituto);

46 Implementando private static boolean substituirnodo(nodo original, Nodo novo) { if (original == null novo == null) { } return false; Nodo pai = original.pai; if (pai!= null) { } if (pai.esquerda == original) { pai.esquerda = novo; } else { } pai.direita = novo; novo.pai = pai; Nodo filho = original.esquerda; if (filho!= null) { } filho.pai = novo; novo.esquerda = filho; } filho = original.direita; if (filho!= null) { } filho.pai = novo; novo.direita = filho; return true; Continuação...

47 Implementando (1/3) public static boolean remover(nodo rem) { if (rem == null) { return false; } //Informação paterna Nodo pai = rem.pai; //Existe um substituto único ou nenhum? Nodo subst; if (rem.esquerda == null rem.direita == null) { //Ambos são null? sem substituto if (rem.esquerda == rem.direita) { subst = null; } else { //Se direita vazia, substituto esta na esquerda e vice versa if (rem.direita == null) { subst = rem.esquerda; } else { subst = rem.direita; } }

48 Implementando (2/3) //Se tiver um pai, atualiza vinculo dos filhos, senão atualiza a raiz. } if (pai!= null) { if (pai.esquerda == rem) { pai.esquerda = subst; } else { pai.direita = subst; } } else { raiz = subst; } //Se tiver um filho substituto, atualiza seu vinculo paterno if (subst!= null) { subst.pai = pai; } return true;

49 Implementando (3/3) //Se chegarmos aqui é por que o nodo excluído tem dois filhos. (Subsequente) //Procuramos o elemento imediatamente maior e que não tenha filho a esquerda Nodo proximo = rem.direita; while (proximo.esquerda!= null) { } proximo = proximo.esquerda; //Removemos o nodo que tem apenas um filho remover(proximo); //Recursividade //Inserimos o nodo "próximo removido" no lugar do "removido" substituirnodo(rem, proximo); } //Se estivermos excluindo a raiz, atualiza ela if (pai == null) { raiz = proximo; } return true;

50 Trabalho Implemente um Árvore Binária de Pesquisa para realizar a inserção, pesquisa, remoção e listagem de um cadastro de alunos. Os alunos serão cadastrados por: Nome (chave, String) Matricula (long) Nome do curso (String) Como nome é o campo chave, a separação esquerda/direita dos elementos deverá ser feita com base nos nomes dos alunos. Exemplo de função para comparar strings de forma alfabética :

51 Árvores ÁRVORES BALANCEADAS Imagem: Natalie Jeremijenko

52 Árvores O pior cenário para uma árvore binária de pesquisa é quando uma sequência de números é inserida já em ordem: Crescente; ou Decrescente.

53 Árvore não Balanceada Entrada: 2, 5, 8, 10,

54 Árvores Para melhorar o tempo de busca em árvores binárias de pesquisa, é possível aplicar técnicas de balanceamento, conforme ilustração a seguir:

55 Balanceando a Árvore

56 Balanceando a Árvore

57 Balanceando a Árvore

58 Árvores AVL O conceito de Árvore AVL foi criado em 1962 por Adelson-Velsky e Landis; É uma árvore binária de pesquisa balanceada; O primeiro diferencial: cada nodo possuí um campo numérico indicando a diferença de altura para cada subárvore filha: 0 : subárvores com mesma altura; 1 : subárvore direita é 1 nível maior; -1 : subárvore esquerda é 1 nível maior;

59 Árvore Binária NÃO AVL: Nível 3 e Ordem 2 Nós / Nodos Arestas A Nível 0 Nó A = Raiz Ordem 2 B Ordem D E C Nível Nível 1 Nó B = Galho Ordem 2 Nó C = Galho Ordem 2 Nível 2 Nó D = Galho Ordem 2 Nó E = Galho Ordem 1 H I Nível 3 Nó H = Folha Ordem 0 Nó I = Folha Ordem 0 Nível 4

60 Diferenças A Nível 0 Nó A: Dif = -2 B C Nível 1 Nó B: Dif = -1 Nó C: Dif = 0 D E Nível 2 Nó D: Dif = 0 Nó E: Dif = 0 H I Nível 3 Nó H: Dif = 0 Nó I: Dif = 0

61 Principal Regra: Árvores AVL Nenhum nodo pode permanecer com diferença maior de nível em qualquer subárvore maior do que 1: 2 2 Sempre que esta condição não for satisfeita, devem ocorrer rotações na árvore, até que ela esteja balanceada, ou seja, com qualquer subárvore

62 Alguma diferença > 1? A Nível 0 Nó A: Dif = -2 B C Nível 1 Nó B: Dif = -1 Nó C: Dif = 0 D E Nível 2 Nó D: Dif = 0 Nó E: Dif = 0 H I Nível 3 Nó H: Dif = 0 Nó I: Dif = 0

63 Árvores AVL Rotações: Diferença Diferença do filho Tipo de Rotação 1 Simples: à esquerda 2 0 Simples: à esquerda -1 Dupla: filho para a direita e pai para a esquerda 1 Dupla: filho para a esquerda e pai para a direita -2 0 Simples: à direita -1 Simples: à direita

64 Diferença do Filho Maior A Nível 0 Nó A: Dif = -2 B C Nível 1 Nó B: Dif = -1 Nó C: Dif = 0 D E Nível 2 Nó D: Dif = 0 Nó E: Dif = 0 H I Nível 3 Nó H: Dif = 0 Nó I: Dif = 0

65 Árvores AVL Rotações: Diferença Diferença do filho Tipo de Rotação 1 Simples: à esquerda 2 0 Simples: à esquerda -1 Dupla: filho para a direita e pai para a esquerda 1 Dupla: filho para a esquerda e pai para a direita -2 0 Simples: à direita -1 Simples: à direita

66 Rotação à Direita A B C D E H I

67 Rotação à Direita A B C D E H I

68 Rotação à Direita B A D C H I E

69 Rotação à Direita B D A H I E C

70 Rotação à Direita B D A H I E C

71 Rotação à Direita B D A H I E C

72 Árvore Binária AVL: Nível 2 e Ordem 2 B Nível 0 Nó B: Dif = 0 D Ordem H I E A C Nível Nível 1 Nó D: Dif = 0 Nó A: Dif = 0 Nível 2 Nó H: Dif = 0 Nó I: Dif = 0 Nó E: Dif = 0 Nó C: Dif = 0 Nível 3

73 Árvores AVL ROTAÇÕES

74 Rotação Simples à Esquerda private boolean RotacaoEsquerda(Nodo centro) { if (centro == null) return false; Nodo aux = centro.direita; if (aux == null) return false; //Atualizar a raiz? if (centro == raiz) raiz = aux; //Troca os pais aux.pai = centro.pai; centro.pai = aux; if (aux.pai!= null) { Nodo pai = aux.pai; if (pai.esquerda == centro) pai.esquerda = aux; else pai.direita = aux; } //Troca os filhos Nodo troca = aux.esquerda; aux.esquerda = centro; centro.direita = troca; return true; }

75 Rotação Simples à Direita private boolean RotacaoDireita(Nodo centro) { if (centro == null) return false; Nodo aux = centro.esquerda; if (aux == null) return false; //Atualizar a raiz? if (centro == raiz) raiz = aux; //Troca os pais aux.pai = centro.pai; centro.pai = aux; if (aux.pai!= null) { Nodo pai = aux.pai; if (pai.esquerda == centro) pai.esquerda = aux; else pai.direita = aux; } //Troca os filhos Nodo troca = aux.direita; aux.direita = centro; centro.esquerda = troca; return true; }

76 Rotação Dupla à Esquerda private boolean RotacaoDuplaEsquerda(Nodo centro) { if (centro == null) return false; Nodo aux = centro.direita; if (aux == null) return false; boolean retorno = RotacaoDireita(aux); if (retorno == false) return false; return RotacaoEsquerda(centro); }

77 Rotação Dupla à Direita private boolean RotacaoDuplaDireita(Nodo centro) { if (centro == null) return false; Nodo aux = centro.esquerda; if (aux == null) return false; boolean retorno = RotacaoEsquerda(aux); if (retorno == false) return false; return RotacaoDireita(centro); }

78 Árvores AVL OUTRAS ALTERAÇÕES

79 Alterações Classe Nodo Novos atributos: public int AltEsq; public int AltDir; public int Dif; Construtor: this.dif = 0; this.altdir = 0; this.altesq = 0;

80 AlturaSubArvore Calculo Dif public int AlturaSubArvore(Nodo atual) { if (raiz == null) return 0; if (atual == null) atual = raiz; if (atual.esquerda == null) atual.altesq = 0; else atual.altesq = AlturaSubArvore(atual.Esquerda) + 1; if (atual.direita == null) atual.altdir = 0; else atual.altdir = AlturaSubArvore(atual.Direita) + 1; atual.dif = atual.altdir - atual.altesq; if (atual.altdir > atual.altesq) return atual.altdir; else return atual.altesq; }

81 Balanceamento da Árvore (1/2) public void BalancearArvore(Nodo atual) { if (raiz == null) return; if (atual == null) atual = raiz; if (atual.dif > 1) { if (atual.direita.dif == -1) RotacaoDuplaEsquerda(atual); else RotacaoEsquerda(atual); return; }

82 Balanceamento da Árvore (2/2) if (atual.dif < -1) { if (atual.esquerda.dif == 1) RotacaoDuplaDireita(atual); else RotacaoDireita(atual); return; } if (atual.esquerda!= null) BalancearArvore(atual.Esquerda); if (atual.direita!= null) BalancearArvore(atual.Direita); }