Aula 16: Pesquisa em Memória Primária - Árvores de Busca. Bruno Hott Algoritmos e Estruturas de Dados I DECSI UFOP

Transcrição

1 Aula 16: Pesquisa em Memória Primária - Árvores de Busca Bruno Hott Algoritmos e Estruturas de Dados I DECSI UFOP

2 Árvores de Pesquisa A árvore de pesquisa é uma estrutura de dados muito eficiente para armazenar informação. Particularmente adequada quando existe necessidade de considerar todos ou alguma combinação de: 1) Acesso direto e sequencial eficientes. 2) Facilidade de inserção e retirada de registros. 3) Boa taxa de utilização de memória. 4) Utilização de memória primária e secundária. 2

3 Árvores Binárias de Pesquisa sem Balanceamento Para qualquer nó que contenha um registro Temos a relação invariante: Todos os registros com chaves menores estão na subárvore à esquerda. Todos os registros com chaves maiores estão na subárvore à direita. 3

4 Árvores Binárias de Pesquisa sem Balanceamento O nível do nó raiz é 0. Se um nó está no nível i então a raiz de suas subárvores estão no nível i+1. A altura de um nó é o comprimento do caminho mais longo deste nó até um nó folha. A altura de uma árvore é a altura do nó raiz. 4

5 TAD-Árvore Binária de Pesquisa typedef struct{ long chave; /* outros componentes */ TRegistro; typedef struct TNo{ TRegistro reg; TNo* pesq, pdir; TNo; typedef TNo* TDicionario; 5

6 Procedimento para Pesquisar na Árvore Para encontrar um registro com uma chave x: 1) Compare-a com a chave que está na raiz. 2) Se x é menor, vá para a subárvore esquerda. 3) Se x é maior, vá para a subárvore direita. 4) Repita o processo recursivamente, até que a chave procurada seja encontrada ou um nó folha é atingido. 5) Se a pesquisa tiver sucesso então o conteúdo do registro retorna no próprio registro x. 6

7 Procedimento para Pesquisar na Árvore ( px * int pesquisa(tno* praiz, TRegistro if(praiz == ( NULL return 0; ( praiz->reg.chave if(px->chave < ;( pesquisa(praiz->pesq,px return ( praiz->reg.chave if(px->chave > ;( pesquisa(praiz->pdir,px return */ ( praiz->reg.chave /* if(px->chave == *px = praiz->reg; return 1; 7

8 Procedimento para Pesquisar na Árvore (não recursivo) ( px * int pesquisa(tno* praiz, TRegistro TNo* paux = praiz; ( NULL while(paux!= ( paux->reg.chave if(px->chave == *px = paux->reg; return 1; ( paux->reg.chave if (px->chave > paux = paux->pdir; */ ( paux->reg.chave else /* if (px->chave < paux = paux->pesq; return 0; 8

9 Procedimento para Inserir na Árvore Onde inserir? Atingir um apontador nulo em um processo de pesquisa significa uma pesquisa sem sucesso. O apontador nulo atingido é o ponto de inserção. Como inserir? Cria célula contendo registro Procura lugar na árvore Se registro não tiver na árvore, insere-o 9

10 Procedimento para Inserir na Árvore ( x int insere(tno** ppraiz, TRegistro ( NULL if(*ppraiz == ;( cria_no(x *ppraiz = return 1; ( reg.chave <-( ppraiz *) if(x.chave < ;( x,( pesq <-( insere(&((*ppraiz return ( reg.chave <-( ppraiz *) if(x.chave > ;( x,( pdir <-( insere(&((*ppraiz return return 0; /* elemento jah existe */ 10

11 Procedimento para Inserir na Árvore (não recursivo) ( x int insere(tno** ppraiz, TRegistro TNo** ppaux = ppraiz; ( NULL while (*ppaux!= ( reg.chave <-( ppaux *) if(x.chave < ;( pesq <-( ppaux *))& ppaux = ( reg.chave <-( ppaux *) else if(x.chave > ;( pdir <-( ppaux *))& ppaux = */ ( reg.chave <-( ppaux *) else /* if(x.chave == return 0; ;( cria_no(x *ppaux = return 1; 11

12 Procedimentos para Inicializar a Árvore ( Dicionario void inicializa(tno** *TDicionario = NULL; 12

13 Retirada de um Registro da Árvore Como retirar? Folha? Nó interno, contendo um filho? Raiz da árvore ou subárvore? 13

14 Procedimento para Retirar x da Árvore A retirada de um registro não é tão simples quanto a inserção. Se o nó que contém o registro a ser retirado possui no máximo um descendente, a operação é simples. No caso do nó conter dois descendentes o registro a ser retirado deve ser primeiro: substituído pelo registro mais à direita na subárvore esquerda; ou pelo registro mais à esquerda na subárvore direita. 14

15 Exemplo de Retirada de um Registro da Árvore para retirar o registro com chave 5 da árvore basta trocá-lo pelo registro com chave 4 ou pelo registro com chave 6, e então retirar o nó que recebeu o registro com chave 5. 15

16 Exemplo de Retirada de um Registro da Árvore ( p int retira(registro x,tno** TNo* paux; ( NULL if(*p == return 0; ( reg.chave <-( p *) if(x.chave < ;( pesq <-( p *)& return retira(x, ( reg.chave <-( p *) if(x.chave > ;( pdir <-( p *)& return retira(x, */ (( p *) /* if(x == ( NULL if((*p)->pdir == paux = *p; *p = (*p)->pesq; ;( free(paux return 1; ( NULL if((*p)->pesq == paux = *p; *p = (*p)->pdir; ;( free(paux return 1; /* dois filhos */ ;( pesq <-( p *)& antecessor(*p, return 1; 16

17 Exemplo de Retirada de um Registro da Árvore ( r void antecessor(tno* q, TNo** TNo* paux; ( NULL (*r)->pdir!= if( ;( pdir <-( r *)& antecessor(q, return; q->reg = (*r)->reg; paux = *r; *r = (*r)->pesq; ;( free(aux 17

18 Exemplo de Retirada de um Registro da Árvore Obs.: proc. recursivo Antecessor só é ativado quando o nó que contém registro a ser retirado possui 2 descendentes. Solução usada por Wirth, 1976, p

19 Outro Exemplo de Retirada de Nó 19

20 Outro Exemplo de Retirada de Nó 20

21 Caminhamento Central Percorrer a árvore: Em que ordem chaves são recuperadas (usando caminhamento central)? 1, 2, 3, 4, 5, 6 e 7. 21

22 Caminhamento Central Após construída a árvore, pode ser necessário percorrer todo os registros que compõem a tabela ou arquivo. Existe mais de uma ordem de caminhamento em árvores, mas a mais útil é a chamada ordem de caminhamento central. Uma característica importante do caminhamento central é que os nós são visitados de forma ordenada. 22

23 Caminhamento Central ( praiz void central(tno* if (praiz == ( NULL return; ;( central(p->pesq ;( p->reg.chave printf("%ld\n", ;( central(p->pdir 23

24 Análise O número de comparações em uma pesquisa com sucesso: melhor caso : C(n) = O(1) pior caso: C(n) = O(n) caso médio : C(n) = O(log n) O tempo de execução dos algoritmos para árvores binárias de pesquisa dependem muito do formato das árvores. 24

25 Análise Para obter o pior caso basta que as chaves sejam inseridas em ordem crescente ou decrescente. Neste caso a árvore resultante é uma lista linear, cujo número médio de comparações é (n + 1)/2. Para uma árvore de pesquisa aleatória o número esperado de comparações para recuperar um registro qualquer é cerca de 1,39 log n, apenas 39% pior que a árvore completamente balanceada. 25