aula 10a pesquisa: introdução · 2020-02-13 · bruno hott 2 introdução – conceitos básicos...

Aula 10a Pesquisa:Introdução

Bruno HottAlgoritmos e Estruturas de Dados IDECSI – UFOP

Bruno Hott 2

Introdução – Conceitos Básicos

● Estudo de como recuperar informação a partir de uma grande massa de informação previamente armazenada.

● A informação é dividida em registros.● Cada registro possui uma chave para ser usada na pesquisa.● Objetivo da pesquisa: Encontrar uma ou mais ocorrências de

registros com chaves iguais à chave de pesquisa.● Pesquisa com sucesso

X Pesquisa sem sucesso.

Bruno Hott 3

Introdução – Conceitos Básicos

● Tabelas– Conjunto de registros ou arquivos TABELAS⇒

– Tabela: associada a entidades de vida curta, criadas na memória interna durante a execução de um programa.

– Arquivo: geralmente associado a entidades de vida mais longa, armazenadas em memória externa.

Bruno Hott 4

Escolha do Método de Pesquisa mais Adequado a uma Determinada Aplicação

● Depende principalmente:– Quantidade dos dados envolvidos.– Arquivo estar sujeito a inserções e retiradas frequentes

● Se conteúdo do arquivo é estável é importante minimizar o tempo de pesquisa, sem preocupação com o tempo necessário para estruturar o arquivo

Bruno Hott 5

Algoritmos de Pesquisa (TADs)

● É importante considerar os algoritmos de pesquisa como tipos abstratos de dados (TADs), com um conjunto de operações associado a uma estrutura de dados, de tal forma que haja uma independência de implementação para as operações.

● Operações mais comuns:

1) Inicializar a estrutura de dados.

2) Pesquisar um ou mais registros com determinada chave.

3) Inserir um novo registro.

4) Retirar um registro específico.

5) Ordenar um arquivo para obter todos os registros em ordem de acordo com a chave.

6) Juntar dois arquivos para formar um arquivo maior.

Bruno Hott 6

Dicionário

● Nome comumente utilizado para descrever uma estrutura de dados para pesquisa.

● Dicionário é um tipo abstrato de dados com as operações:

1) Inicializa

2) Pesquisa

3) Insere

4) Retira● Analogia com um dicionário da língua portuguesa:

– Chaves palavras– Registros entradas associadas com

*pronúncia, definição, sinônimos, outras informações

Bruno Hott 7

Pesquisa Sequencial

● Método de pesquisa mais simples:– a partir do primeiro registro, pesquise seqüencialmente até encontrar

a chave procurada; então pare.

● Armazenamento de um conjunto de registros por meio do tipo estruturado arranjo

Bruno Hott 8

Pesquisa Sequencial

#define MAX 10

typedef struct{ long Chave; /* outros componentes */}TRegistro;

typedef struct{ TRegistro Item[MAX+1]; int n;}TTabela;

Bruno Hott 9

Pesquisa Sequencial

//Implementação para as operações Inicializa, Pesquisa:

void inicializa(TTabela *T){ T->n = 0;}

int pesquisa_seq(TTabela *T, long x){ int i; T->Item[0].chave = x; i = T->n; while(T->Item[i].chave != x) i--; return i;}

Bruno Hott 10

Pesquisa Sequencial

//Implementação para a operacao Insere:

void Insere(Registro Reg, TTabela *T){ if(T->n == MAX) printf("Erro : tabela cheia\n"); else{ T->n++; T->Item[T->n] = Reg; }}

Bruno Hott 11

Pesquisa Sequencial

● Pesquisa retorna o índice do registro que contém a chave x;● Caso não esteja presente, o valor retornado é zero.● A implementação não suporta mais de um registro com uma

mesma chave.● Para aplicações com esta característica é necessário incluir um

argumento a mais na função Pesquisa para conter o índice a partir do qual se quer pesquisar.

Bruno Hott 12

Pesquisa Sequencial

● Utilização de um registro sentinela na posição zero do array:– Garante que a pesquisa sempre termina: se o índice retornado por

Pesquisa for zero, a pesquisa foi sem sucesso.– Não é necessário testar se i > 0, devido a isto:

● o anel interno da função Pesquisa é extremamente simples: o índice i é decrementado e a chave de pesquisa é comparada com a chave que está no registro.

● isto faz com que esta técnica seja conhecida como pesquisa sequencial rápida.

Bruno Hott 13

Pesquisa Sequencial - Análise

● Pesquisa com sucesso:– melhor caso: C(n) = 1– pior caso: C(n) = n– caso médio: C(n) = (n + 1) / 2

● Pesquisa sem sucesso:– C (n) = n + 1.

● O algoritmo de pesquisa sequencial é a melhor escolha para o problema de pesquisa em tabelas com até 25 registros.

Bruno Hott 14

Pesquisa Binária

● Pesquisa em tabela pode ser mais eficiente se registros forem mantidos em ordem

● Para saber se uma chave está presente na tabela

1) Compare a chave com o registro que está na posição do meio da tabela.

2) Se a chave é menor então o registro procurado está na primeira metade da tabela

3) Se a chave é maior então o registro procurado está na segunda metade da tabela.

4) Repita o processo até que a chave seja encontrada, ou fique apenas um registro cuja chave é diferente da procurada, significando uma pesquisa sem sucesso.

Bruno Hott 15

Exemplo de Pesquisa Binária para a Chave G

Bruno Hott 16

Pesquisa Binária

int pesquisa_binaria(TTabela *T, long x){ int i, esq, dir;

if(T->n == 0) return 0;

esq = 1; dir = T->n; do{ i = (Esq + Dir) / 2; if(x > T->Item[i].Chave) esq = i+1; else dir = i-1; while( (x != T->Item[i].Chave) && (esq <= dir) );

if(x == T->Item[i].chave) return i; else return 0;

}

Bruno Hott 17

Pesquisa Binária - Análise

● A cada iteração do algoritmo, o tamanho da tabela é dividido ao meio.

● Logo: o número de vezes que o tamanho da tabela é dividido ao meio é cerca de log n.

● Ressalva: o custo para manter a tabela ordenada é alto: a cada inserção na posição p da tabela implica no deslocamento dos registros a partir da posição p para as posições seguintes.

● Consequentemente, a pesquisa binária não deve ser usada em aplicações muito dinâmicas.

Bruno Hott 1

Aula 10b Pesquisa:Árvores de Busca


Bruno Hott 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.

Bruno Hott 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.

Bruno Hott 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.

Bruno Hott 5

TAD - Árvore Binária de Pesquisa

typedef struct{ long chave; /* outros componentes */}TRegistro;

typedef struct TNo{ TRegistro reg; struct TNo *pEsq, *pDir;}TNo;

typedef TNo* TDicionario;

Bruno Hott 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.

Bruno Hott 7

Procedimento para Pesquisar na Árvore

int pesquisa(TNo* pRaiz, TRegistro *pX){ if(pRaiz == NULL) return 0;

if(pX->chave < pRaiz->reg.chave) return pesquisa(pRaiz->pEsq,pX); if(pX->chave > pRaiz->reg.chave) return pesquisa(pRaiz->pDir,pX);

/* if(pX->chave == pRaiz->reg.chave) */ *pX = pRaiz->reg; return 1;}

Bruno Hott 8

Procedimento para Pesquisar na Árvore (não recursivo)

int pesquisa(TNo* pRaiz, TRegistro *pX){ TNo* pAux = pRaiz;

while(pAux != NULL){ if(pX->chave == pAux->reg.chave){ *pX = pAux->Reg; return 1;

if (pX->chave > pAux->reg.chave) pAux = pAux->pDir; else /* if (pX->chave < pAux->reg.chave) */ pAux = pAux->pEsq; } return 0;}

Bruno Hott 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

Bruno Hott 10

Procedimento para Inserir na Árvore

int insere(TNo** ppRaiz, TRegistro x){ if(*ppRaiz == NULL){ *ppRaiz = cria_no(x); return 1; }

if(x.chave < (*ppRaiz)->reg.chave) return insere(&((*ppRaiz)->pEsq), x); if(x.chave > (*ppRaiz)->reg.chave) return insere(&((*ppRaiz)->pDir), x); return 0; /* elemento jah existe */}

Bruno Hott 11

Procedimento para Inserir na Árvore (não recursivo)

int insere(TNo** ppRaiz, TRegistro x){ TNo** ppAux = ppRaiz;

while (*ppAux != NULL){ if(x.chave < (*ppAux)->reg.Chave) ppAux = &((*ppAux)->pEsq); else if(x.chave > (*ppAux)->reg.chave) ppAux = &((*ppAux)->pDir); else /* if(x.chave == (*ppAux)->reg.chave) */ return 0; }

*ppAux = cria_no(x); return 1;}

Bruno Hott 12

Procedimentos para Inicializar a Árvore

void inicializa(TNo** Dicionario){ *TDicionario = NULL;}

Bruno Hott 13

Retirada de um Registro da Árvore

● Como retirar?

● Folha?● Nó interno, contendo um filho?● Raiz da árvore ou subárvore?

Bruno Hott 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.

Bruno Hott 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.

Bruno Hott 16


int retira(Registro x, Tno** p){ TNo* pAux;

if(*p == NULL) return 0; if(x.chave < (*p)->reg.chave) return retira(x, &(*p)->pEsq); if(x.chave > (*p)->reg.chave) return retira(x, &(*p)->pDir);

/* if(x == (*p)) */ if((*p)->pDir == NULL){ pAux = *p; *p = (*p)->pEsq; free(pAux); return 1; } if((*p)->pEsq == NULL){ pAux = *p; *p = (*p)->pDir; free(pAux); return 1; } /* dois filhos */ antecessor(*p, &(*p)->pEsq); return 1;}

Bruno Hott 17


void antecessor(TNo* q, TNo** r){ TNo* pAux; if( (*r)->pDir != NULL){ antecessor(q, &(*r)->pDir); return; } q->reg = (*r)->reg; pAux = *r; *r = (*r)->pEsq; free(pAux);}

Bruno Hott 18


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.211.

Bruno Hott 19

Caminhamento Central

Percorrer a árvore:

Em que ordem chaves são recuperadas (usando caminhamento central)?

1, 2, 3, 4, 5, 6 e 7.

Bruno Hott 20


● 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.

Bruno Hott 21


void central(TNo* pRaiz){ if (pRaiz == NULL) return;

central(p->pEsq); printf("%ld\n", p->reg.chave); central(p->pDir);}

Bruno Hott 22

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.

Bruno Hott 23

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.

Bruno Hott 1

Aula 10c Pesquisa:Árvores AVL


Bruno Hott 2

Árvore AVL

● Árvore binária de busca tal que, para qualquer nó interno v, a diferença das alturas dos filhos de v é no máximo 1.

● Árvores AVL são balanceadas

88

44

17 78

32 50

48 62

2

4

1

1

2

3

1

1

Bruno Hott 3

Árvores Binárias Balanceadas e AVL

● Inserindo os nós 30, 20, 40, 10, 25, 35 e 50 nesta ordem, teremos:

30

20

10 25

40

35 50

Bruno Hott 4

Árvores Binárias Balanceadas e AVL

● Inserindo os nós 10, 20, 30, 40 e 50 nesta ordem, teremos:

10

20

30

40

50

Bruno Hott 5

Árvores Binárias Balanceadas

● Existem ordens de inserção de nós que conservam o balanceamento de uma árvore binária.

● Na prática é impossível prever essa ordem ou até alterá-la.

Bruno Hott 6

Árvores Binárias Balanceadas

● A vantagem de uma árvore balanceada com relação a uma degenerada está em sua eficiência.

● Por exemplo: numa árvore binária degenerada de 1.000.000 nós são necessárias, em média, 500.000 comparações (semelhança com arrays ordenados e listas encadeadas).

● Numa árvore balanceada com o mesmo número de nós essa média reduz-se a 20 comparações.

Bruno Hott 7

AVL

● Algoritmo de balanceamento de árvores binárias.● A origem da denominação AVL vem dos seus dois criadores: Adel’son-Vel’skii e Landis.

● Ano de divulgação: 1962.

Bruno Hott 8

Árvore AVL (TAD)

typedef struct{ long chave; /* outros componentes */}TRegistro;

typedef struct TNo{ TRegistro reg; TNo *pEsq, *pDir;}TNo;

typedef TNo* TipoDicionario;

Bruno Hott 9

Árvores AVL

● Uma árvore binária balanceada é aquela na qual, para cada nó, as alturas de suas sub-árvores esquerda e direita diferem de, no máximo, 1.

● Fator de balanceamento (FB) de um nó é a diferença entre a altura da sub-árvore esquerda em relação à sub-árvore direita.

FB(p) = altura(sub-árvore esquerda de p)

- altura(sub-árvore direita de p)● Em uma árvore binária balanceada todos os FB de todos os nós

estão no intervalo -1 FB 1

Bruno Hott 10

FB e Altura

int fb(TNo* pRaiz){ if(pRaiz == NULL) return 0;

return altura(pRaiz->pEsq) - altura(pRaiz->pDir);}

int altura(TNo* pRaiz){ int hEsq,hDir; if(pRaiz == NULL) return 0;

hEsq = altura(pRaiz->pEsq); hDir = altura(pRaiz->pDir);

if(hEsq > hDir) return hEsq+1; else return hDir+1;}

Bruno Hott 11

AVL

● Inicialmente inserimos um novo nó na árvore normalmente.● A inserção deste pode degenerar a árvore.● A restauração do balanceamento é feita através de rotações na

árvore no nó “pivô”.● Nó “pivô” é aquele que após a inserção possui fator de

balanceamento fora do intervalo.

Bruno Hott 12

AVL

● Rotação simples para a direita (RSD)– FB > 1 (subárvore esquerda maior que subárvore direita)– E a subárvore esquerda desta subárvore esquerda é maior que a

subárvore direita dela– Então realizar uma rotação simples para a direita.

3

2

1

Bruno Hott 13

AVL

● Rotação simples para a direita (RSD)

3

2

1

2

1 3

Bruno Hott 14

AVL

● Rotação simples para a esquerda (RSE)– FB < -1 (subárvore esquerda menor que subárvore direita)– E a subárvore direita desta subárvore direita é maior que a subárvore

esquerda dela– Então realizar uma rotação simples para a esquerda.

1

2

3

Bruno Hott 15

AVL

● Rotação simples para a esquerda (RSE)

1

2

3

2

1 3

Bruno Hott 16

AVL

● Rotação dupla para a direita (rotação esquerda-direita - RED)– FB > 1 (subárvore esquerda maior que subárvore direita)– E a subárvore esquerda desta subárvore esquerda é menor ou igual

que a subárvore direita dela– Então realizar uma rotação dupla para a direita.

1

3

2

Bruno Hott 17

AVL

● Rotação dupla para a direita (rotação esquerda-direita - RED)

1

3

2

2

1 3

3

2

1

Bruno Hott 18

AVL

● Rotação dupla para a esquerda (rotação direita-esquerda RDE)

FB < -1 (subárvore esquerda menor que subárvore direita)– E a subárvore direita desta subárvore direita é menor que a subárvore

esquerda dela– Então realizar uma rotação dupla para a esquerda.

Bruno Hott 19

AVL

● Rotação dupla para a esquerda (rotação direita-esquerda RDE)

1

3

2

1

2

3

2

1 3

Bruno Hott 20

Rotações Simples

void rse(TNo** ppRaiz){ TNo *pAux;

pAux = (*ppRaiz)->pDir; (*ppRaiz)->pDir = pAux->pEsq; pAux->pEsq = (*ppRaiz); (*ppRaiz) = pAux;}

void rsd(TNo** ppRaiz){ /* para casa */}

Bruno Hott 21

Rotações Duplas

int balanca_direita(TNo** ppRaiz{ int fbd = fb((*ppRaiz)->pDir); if(fbd <= 0){ rse(ppRaiz); return 1; else if(fbd > 0){ /* rotacao dupla esquerda */ rsd(&((*ppRaiz)->pDir)); rse(ppRaiz); /* &(*ppRaiz) */ return 1; } return 0;}

int balanca_esquerda(TNo** ppRaiz){ /* para casa */}

Bruno Hott 22

Balanceamento

int balanceamento(TNo** ppRaiz){ int fb = fb(*ppRaiz); if(fb > 1) return balanca_esquerda(ppRaiz); else if (fb < -1) return balanca_direita(ppRaiz); else return 0;}

Bruno Hott 23

Inserção em uma Árvore AVL

● Inserção como em uma árvore binária de pesquisa● Sempre feita expandindo um nó externo. Exemplo:

Bruno Hott 24

Reestruturação Trinodo

● x, y, z (filho, pai e avô) renomeados como a,b,c (percurso interfixado)

● rotações levam b para o topo

Caso 1: rotação simples à esquerda

Caso 2: rotação dupla à esquerda

(outros dois casos são simétricos)

Bruno Hott 25

Exemplo de inserção (cont.)

88

44

17 78

32 50

48 62

2

5

1

1

3

4

2

1

54

1

T0 T2

T3

x

y

z

2

34

5

67

1

T1

88

44

17

7832 50

48

622

4

1

1

2 2

3

154

1

T 0 T1

T2

T3

x

y z

123

4

5

6

7

Desbalanceado

Balanceado

Bruno Hott 26

Inserção

int insere(TNo** ppRaiz, TRegistro* x){ if (*ppRaiz == NULL){ *ppRaiz=(Tno*)malloc(sizeof(TNo)); (*ppRaiz)->reg = *x; (*ppRaiz)->pEsq = NULL; (*ppRaiz)->pDir = NULL; return 1; }else if((*ppRaiz)->reg.chave > x->chave){ if(insere(&(*ppRaiz)->pEsq,x)){ if(balanceamento(ppRaiz)) return 0; else return 1; } }

else if((*ppRaiz)->reg.chave < x->chave){ if(insere(&(*ppRaiz)->pDir, x)){ if(balanceamento(ppRaiz) return 0; else return 1; }else return 0; }else return 0; /* valor já presente */}

Bruno Hott 27

Implementação de Inserção

● Cálculo de fatores de balanceamento– Custo: O(log n) ??

● Como melhorar?– Cada nó:

● Fator de balanceamento● Profundidade x Altura

● Problema: atualizar dados durante rotações

Bruno Hott 28

Remoção em uma árvore AVL

● Remoção em uma árvore binária de busca pode causar desbalanceamento. Exemplo:

Bruno Hott 29

Rebalanceamento após uma remoção

● Seja z o primeiro nó desbalanceado encontrado acima de w. Seja y o filho de z com maior altura, e x o filho de y com maior altura.

● Executar restructure(x) para rebalancear z.

● Pode ocorrer desbalanceamento de outro nó acima, continuar verificação de balanceamento até à raiz.

Bruno Hott 30

Remoção

int remove (TNo** ppRaiz, Registro* pX){ if(*ppRaiz == NULL) return 0; else if ((*ppRaiz)->reg.chave == pX->chave){ *pX = (*ppRaiz)->reg; antecessor(ppRaiz, &((*ppRaiz)->pEsq)); balanceamento(ppRaiz); return 1; }else if((*ppRaiz)->reg.chave > pX->chave){ if(remove((*ppRaiz)->pEsq, pX)){ balanceamento(ppRaiz); return 1; }else return 0; }else /* código para sub-árvore direita */}

Bruno Hott 31

Tempos de execução para árvores AVL

● uma única reestruturação é O(1)– usando uma árvore binária implementada – com estrutura ligada

● pesquisa é O(log n)– altura de árvore é O(log n), não necesita reestruturação

● inserir é O(log n)– busca inicial é O(log n)– reestruturação para manter balanceamento é O(log n)

● remove é O(log n)– busca inicial é O(log n)– reestruturação para manter balanceamento é O(log n)

Bruno Hott 32

Verificação

int eh_arvore_avl(TNo* pRaiz){ int fb; if(pRaiz == NULL) return 1;

if(!eh_arvore_avl(pRaiz->pEsq)) return 0; if(!eh_arvore_avl(pRaiz->pDir)) return 0;

fb = fb(pRaiz); if( (fb > 1) || (fb < -1) ) return 0; else return 1;}

Aula 10c Pesquisa:Árvores Vermelho-Preto


Bruno Hott 2

Revisando Árvores Binárias de Busca (BST)

● Árvores binárias ordenadas● Nós podem ter 2 subárvotes● Item à esquerda de um dado nó é menor que ele● Item à direita de um dado nó é maior que ele

Bruno Hott 3

Árvores de busca balanceadas

● Garantido altura de O(log n) para n itens.

Bruno Hott 4

Árvore vermelho-preto

● Um nó é vermelho ou preto● A raíz e as folhas (NIL) são pretas● Se um nó é vermelho, então seus filhos são pretos.● Todos os caminhos de um nó até seus descendentes NIL contem o

mesmo número de nós pretos.

Bruno Hott 5


Bruno Hott 6


Bruno Hott 7


Bruno Hott 8


Bruno Hott 9


Bruno Hott 10


● É necessário um bit extra para armazenar a cor do nó● O maior caminho (raíz ao NIL mais profundo) não é mais do que

duas vezes o tamanho do menor caminho (raíz ao NIL mais próximo).– Menor caminho: todos os nós são pretos– Maior caminho: nós se alternam entre vermelho e preto.

Bruno Hott 11


● Operações– Busca – O(log n)– Inserção – O(log n)– Remoção – O(log n)

Bruno Hott 12

Árvore vermelho-preto - Rotações

● Altera a estrutura da árvore movimentando as sub-árvores● Objetivo é dminuir a altura da árvore

– Sub-árvores maiores sobrem– Sub-árvores menores descem

● Não afeta a ordem dos elementos

Bruno Hott 13


Bruno Hott 14


Bruno Hott 15

Árvore vermelho-preto - Inserções

Bruno Hott 16


● Insere Z e colore de vermelho● Recolora e rotacione nós para concertar as violações

– 4 cenários possíveis:1) Z = root Z

2) Z.uncle = red

3) Z.uncle = black (triangle)

4) Z.uncle = black (line)

Bruno Hott 17


Bruno Hott 18


Bruno Hott 19


Bruno Hott 20


Bruno Hott 21


Bruno Hott 22


Bruno Hott 23


Bruno Hott 24


Bruno Hott 25


Bruno Hott 26


Bruno Hott 27


Bruno Hott 28


Bruno Hott 29

Árvore vermelho-preto - Inserções (revisão)

● Insere Z e colore de vermelho● Recolora e rotacione nós para concertar as violações

– 4 cenários possíveis:1) Z = root Z colorir de preto

2) Z.uncle = red recolorir

3) Z.uncle = black (triangle) rotacionar Z.parent

4) Z.uncle = black (line) rotacionar Z.grandparent & recolorir

Bruno Hott 30


Bruno Hott 31

Árvore vermelho-preto - Inserções (exemplo)

Bruno Hott 32


Bruno Hott 33


Bruno Hott 34


Bruno Hott 35


Bruno Hott 36


Bruno Hott 37


Bruno Hott 38


Bruno Hott 39


Bruno Hott 40


Bruno Hott 41


Bruno Hott 42

Árvore vermelho-preto - Complexidade de tempo

● Inserção: O(log n)● Colorir de vermelho: O(1)● Corrigir violações: O(log n)

– Recolorir: O(1)– Rotacionar: O(1)

Bruno Hott 43

AVL vs Vermelho-Preto

● Quando usar cada uma?

Aula 10e Pesquisa:Árvores Trie/Patrícia


Bruno Hott 2

Pesquisa Digital

● Pesquisa digital é baseada na representação das chaves como uma seqüência de caracteres ou de dígitos.

● Os métodos de pesquisa digital são particularmente vantajosos quando as chaves são grandes e de tamanho variável.

● Um aspecto interessante quanto aos métodos de pesquisa digital é a possibilidade de localizar todas as ocorrências de uma determinada cadeia em um texto, com tempo de resposta logarítmico em relação ao tamanho do texto.– Trie– Patrícia

Bruno Hott 3

Trie

● Uma trie é uma árvore M-ária cujos nós são vetores de M componentes com campos correspondentes aos dígitos ou caracteres que formam as chaves.

● Cada nó no nível i representa o conjunto de todas as chaves que começam com a mesma seqüência de i dígitos ou caracteres.

● Este nó especifica uma ramificação com M caminhos dependendo do (i+1)-ésimo dígito ou caractere de uma chave.

Bruno Hott 4

Trie

● Considerando as chaves como seqüência de bits (isto é, M = 2), o algoritmo de pesquisa digital é semelhante ao de pesquisa em árvore, exceto que, em vez de se caminhar na árvore de acordo com o resultado de comparação entre chaves, caminha-se de acordo com os bits de chave.

Bruno Hott 5

Exemplo

● Dada as chaves de 6 bits:– B = 010010– C = 010011– H = 011000– J = 100001– Q = 101000

Bruno Hott 6

Inserção das Chaves W e K na Trie Binária

● Faz-se uma pesquisa na árvore com a chave a ser inserida. Se o nó externo em que a pesquisa terminar for vazio, cria-se um novo nó externo nesse ponto contendo a nova chave, exemplo: a inserção da chave W = 110110.

● Se o nó externo contiver uma chave cria-se um ou mais nós internos cujos descendentes conterão a chave já existente e a nova chave. exemplo: inserção da chave K = 100010.

Bruno Hott 7

Inserção das Chaves W e K na Trie Binária

Bruno Hott 8

Considerações Importantes sobre as Tries

● O formato das tries, diferentemente das árvores binárias comuns, não depende da ordem em que as chaves são inseridas e sim da estrutura das chaves através da distribuição de seus bits.

● Desvantagem:– Uma grande desvantagem das tries é a formação de caminhos de uma

só direção para chaves com um grande número de bits em comum.– Exemplo: Se duas chaves diferirem somente no último bit, elas

formarão um caminho cujo comprimento é igual ao tamanho delas, nao importando quantas chaves existem na árvore.

– Caminho gerado pelas chaves B e C.

Bruno Hott 9

Praticia – Practical Algorithm To Retrieve Information Coded in Alphanumeric

● Criado por Morrison D. R. 1968 para aplicação em recuperacao de informação em arquivos de grande porte.

● Knuth D. E. 1973: novo tratamento algoritmo● Reapresentou-o de forma mais clara como um caso particular de

pesquisa digital, essencialmente, um caso de árvore trie binaria● Sedgewick R. 1988 apresentou novos algoritmos de pesquisa e de

inserção baseados nos algoritmos propostos por Knuth● Gonnet, G. H. e Baeza-Yates R. 1991 propuseram também outros

algoritmos

Bruno Hott 10

Mais sobre Patricia

● O algoritmo para construção da árvore Patricia é baseado no método de pesquisa digital, mas sem apresentar o inconveniente citado para o caso das tries.

● O problema de caminhos de uma só direção é eliminado por meio de uma solução simples e elegante: cada nó interno da árvore contém o índice do bit a ser testado para decidir qual ramo tomar.

● Exemplo: dada as chaves de 6 bits:– B = 010010

– C = 010011

– H = 011000

– J = 100001

– Q = 101000

Bruno Hott 11

Inserção da Chave K

● Para inserir a chave K = 100010 na árvore acima, a pesquisa inicia pela raiz e termina quando se chega ao nó externo contendo J.

● Os índices dos bits nas chaves estão ordenados da esquerda para a direita. – Bit de índice 1 de K é 1 → a subárvore direita – Bit de índice 3 → subárvore esquerda que neste caso é um nó externo.

● Chaves J e K mantêm o padrão de bits 1x0xxx, assim como qualquer outra chave que seguir este caminho de pesquisa.

Bruno Hott 12

Inserção da Chave W

● A inserção da chave W = 110110 ilustra um outro aspecto.● Os bits das chaves K e W são comparados a partir do 1o para determinar em qual

índice eles diferem, sendo, neste caso, o de índice 2.● Portanto: o ponto de inserção agora será no caminho de pesquisa entre os nós

internos de índice 1 e 3.● Cria-se aí um novo nó interno de índice 2, cujo descendente direito é um nó

externo contendo W e cujo descendente esquerdo é a subárvore de raiz de índice 3.

Bruno Hott 13

Estrutura de Dados

#define D 8 /* depende de ChaveTipo */

typedef unsigned char ChaveTipo;

typedef unsigned char IndexAmp;

typedef unsigned char Dib;

typedef enum{ Interno, Externo;}NoTipo;

typedef struct PatNo* Arvore;

Bruno Hott 14

Estrutura de Dados

typedef struct PatNo{ NoTipo nt; union{ struct{ IndexAmp Index; Arvore Esq, Dir; }NInterno; ChaveTipo Chave; }NO;}PatNo;

Bruno Hott 15

Funções Auxiliares

/* Retorna o i-esimo bit de k a partir da esquerda */Dib Bit(IndexAmp i, ChaveTipo k){ int c, j; if (i == 0) return 0; else{ c = k; for (j = 1; j <= D - i; j++) c /= 2; return (c & 1); }}/* Verifica se p e nodo externo */short EExterno(Arvore p) return (p->nt == Externo);}

Bruno Hott 16

Procedimento para Criar os Nós

Arvore CriaNoInt(int i, Arvore *Esq, Arvore *Dir){ Arvore p; p =(Arvore) malloc(sizeof(PatNo)); p->nt = Interno; p->NO.NInterno.Esq = *Esq; p->NO.NInterno.Dir = *Dir; p->NO.NInterno.Index = i; return p;}Arvore CriaNoExt(ChaveTipo k){ Arvore p; p = (Arvore) malloc(sizeof(PatNo)); p->nt = Externo; p->NO.Chave = k; return p;}

Bruno Hott 17

Algoritmo de Pesquisa

void Pesquisa(ChaveTipo k, Arvore t){ if (EExterno(t)) { if (k == t->NO.Chave) printf("Elemento encontrado\n"); else printf("Elemento nao encontrado\n"); return; } if (Bit(t->NO.NInterno.Index, k) == 0) Pesquisa(k, t→NO.NInterno.Esq); else Pesquisa(k, t->NO.Ninterno.Dir);}

Bruno Hott 18

Descrição Informal do Algoritmo de Inserção

● Cada chave k é inserida de acordo com os passos, partindo da raiz:

1) Se a subárvore corrente for vazia, então é criado um nó externo contendo a chave k (isto ocorre somente na inserção da primeira chave) e o algoritmo termina.

Bruno Hott 19

Descrição Informal do Algoritmo de Inserção

2) Se a subárvore corrente for simplesmente um nó externo, os bits da chave k são comparados, a partir do bit de índice imediatamente após o último índice da seqüência de índices consecutivos do caminho de pesquisa, com os bits correspondentes da chave k’ deste nó externo até encontrar um índice i cujos bits difiram. A comparação dos bits a partir do último índice consecutivo melhora consideravelmente o desempenho do algoritmo. Se todos forem iguais, a chave já se encontra na árvore e o algoritmo termina; senão, vai-se para o Passo 4.

3) Se a raiz da subárvore corrente for um nó interno, vai-se para a subárvore indicada pelo bit da chave k de índice dado pelo nó corrente, de forma recursiva.

Bruno Hott 20

Algoritmo de Inserção

4) Depois são criados um nó interno e um nó externo: o primeiro contendo o índice i e o segundo, a chave k. A seguir, o nó interno é ligado ao externo pelo apontador de subárvore esquerda ou direita, dependendo se o bit de índice i da chave k seja 0 ou 1, respectivamente.

5) O caminho de inserção é percorrido novamente de baixo para cima, subindo com o par de nós criados no Passo 4 até chegar a um nó interno cujo índice seja menor que o índice i determinado no Passo 2. Este é o ponto de inserção e o par de nós é inserido.

Bruno Hott 21


Arvore InsereEntre(ChaveTipo k, Arvore *t, int i){ Arvore p; if ((EExterno(*t)) || (i < (*t)->NO.NInterno.Index)){ /* cria um novo noh externo */ p = CriaNoExt(k); if (Bit(i, k) == 1) return (CriaNoInt(i, t, &p)); else return (CriaNoInt(i, &p, t)); } else{ if (Bit((*t)->NO.NInterno.Index, k) == 1) (*t)->NO.NInterno.Dir = InsereEntre(k, &(*t)->NO.NInterno.Dir, i); else (*t)->NO.NInterno.Esq = InsereEntre(k, &(*t)->NO.NInterno.Esq, i); return (*t); }}

Bruno Hott 22


Arvore Insere(ChaveTipo k, Arvore *t){ Arvore p; int i; if (*t == NULL) return (CriaNoExt(k)); p = *t; while (!EExterno(p)){ if (Bit(p->NO.NInterno.Index, k) == 1) p = p->NO.Ninterno.Dir; else p = p->NO.NInterno.Esq; } /* acha o primeiro bit diferente */ i = 1; while ((i <= D) && (Bit((int)i, k) == Bit((int)i, p→NO.Chave))) i++; if (i > D){ printf("Erro: chave ja esta na arvore\n"); return (*t); } else return (InsereEntre(k, t, i));}

Aula 10f Pesquisa:Hashing


Bruno Hott 2

Transformação de Chave (Hashing)

● Os registros armazenados em uma tabela são diretamente endereçados a partir de uma transformação aritmética sobre a chave de pesquisa

● Hash significa:– Fazer picadinho de carne e vegetais para cozinhar.– Fazer uma bagunça. (Webster’s New World Dictionary)– Espalhar x Transformar (informática x computação)

Bruno Hott 3


● Um método de pesquisa com o uso da transformação de chave é constituído de duas etapas principais:

1) Computar o valor da função de transformação, a qual transforma a chave de pesquisa em um endereço da tabela.

2) Considerando que duas ou mais chaves podem ser transformadas em um mesmo endereço de tabela, é necessário existir um método para lidar com colisões.

● Qualquer que seja a função de transformação, algumas colisões irão ocorrer fatalmente, e tais colisões têm de ser resolvidas.

● Mesmo que se obtenha uma função de transformação que distribua os registros de forma uniforme entre as entradas da tabela, existe uma alta probabilidade de haver colisões.

Bruno Hott 4


● O paradoxo do aniversário (Feller,1968, p. 33), diz que em um grupo de 23 ou mais pessoas, juntas ao acaso, existe uma chance maior do que 50% de que 2 pessoas comemorem aniversário no mesmo dia.

● Assim, se for utilizada uma função de transformação uniforme que enderece 23 chaves randômicas em uma tabela de tamanho 365, a probabilidade de que haja colisões é maior do que 50%.

Bruno Hott 5


● A probabilidade p de se inserir N itens consecutivos sem colisão em uma tabela de tamanho M é:

Bruno Hott 6


● Alguns valores de p para diferentes valores de N, onde M = 365.

● Para N pequeno a probabilidade p pode ser aproximada por p ≈ N (N −1))/730. Por exemplo, para N = 10 então p ≈ 87,7%.

N P

10 0,883

22 0,524

23 0,493

30 0,303

Bruno Hott 7

Funções de Transformação

● Uma função de transformação deve mapear chaves em inteiros dentro do intervalo [0 … M−1], onde M é o tamanho da tabela.

● A função de transformação ideal é aquela que:– Seja simples de ser computada.– Para cada chave de entrada, qualquer uma das saídas possíveis é

igualmente provável de ocorrer.

Bruno Hott 8

Método mais Usado

● Usa o resto da divisão por M.h(K) = K % M (em linguagem C)

onde K é um inteiro correspondente à chave.

Bruno Hott 9

Método mais Usado

● Cuidado na escolha do valor de M.● M deve ser um número primo, mas não qualquer primo: devem ser

evitados os números primos obtidos a partir debi ± j● onde b é a base do conjunto de caracteres (geralmente b = 64

para BCD, 128 para ASCII, 256 para EBCDIC, ou 100 para alguns códigos decimais), e i e j são pequenos inteiros.

Bruno Hott 10

Transformações de Chaves não numéricas

● As chaves não numéricas devem ser transformadas em números:

● n é o número de caracteres da chave.● Chave[i] corresponde à representação ASCII do i-ésimo caractere da

chave.● p[i] é um inteiro de um conjunto de pesos gerados randomicamente

para 1 ≤ i ≤ n.

Bruno Hott 11


● Vantagem de se usar pesos: Dois conjuntos diferentes de pesos p1[i] e p2[i], 1 ≤ i ≤ n, leva a duas funções de transformação h1(K) e h2(K) diferentes.

Bruno Hott 12


● Programa que gera um peso para cada caractere de uma chave constituída de n caracteres:/* Gera valores randomicos entre 1 e 10.000 */void GeraPesos(TipoPesos p){ int i; struct timeval semente; gettimeofday(&semente,NULL); srand((int)(semente.tv_sec + 1000000 * semente.tv_usec)); for (i = 0; i < n; i++) p[i] = 1 + (int) (10000.0 * rand() / (RAND_MAX+1.0));}

Bruno Hott 13


● Implementação da função de transformação:

Indice h(TipoChave Chave, TipoPesos p){ int i; unsigned int soma = 0; int comp = strlen(Chave);

for (i = 0; i < comp; i++) soma += (unsigned int) Chave[i] * p[i]; return (soma % M);}

Bruno Hott 14

Resolvendo colisões

● Listas Encadeadas● Endereçamento Aberto

Bruno Hott 15

Listas Encadeadas

● Uma das formas de resolver as colisões é simplesmente construir uma lista linear encadeada para cada endereço da tabela. Assim, todas as chaves com mesmo endereço são encadeadas em uma lista linear.

Bruno Hott 16

Listas Encadeadas

● Exemplo: Se a i-ésima letra do alfabeto é representada pelo número i e a função de transformação h(Chave) = Chave mod M é utilizada para M = 7, o resultado da inserção das chaves P E S Q U I S A na tabela é o seguinte:

● Por exemplo, h(A) = h(1) = 1, h(E) = h(5) = 5, h(S) = h(19) = 5, etc

Bruno Hott 17

Endereçamento Aberto

● Quando o número de registros a serem armazenados na tabela puder ser previamente estimado, então não haverá necessidade de usar apontadores para armazenar os registros.

● Existem vários métodos para armazenar N registros em uma tabela de tamanho M > N , os quais utilizam os lugares vazios na própria tabela para resolver as colisões. (Knuth, 1973, p.518)

Bruno Hott 18

Endereçamento Aberto

● No Endereçamento aberto todas as chaves são armazenadas na própria tabela, sem o uso de apontadores explícitos.

● Existem várias propostas para a escolha de localizações alternativas. A mais simples é chamada de hashing linear, onde a posição hj na tabela é dada por:hj = (h(x) + j) mod M, para 1 ≤ j ≤ M − 1.

Bruno Hott 19

Exemplo

● Se a i-ésima letra do alfabeto é representada pelo número i e a função de transformação h(Chave) = Chave mod Mé utilizada para M = 7,

● então o resultado da inserção das chaves L U N E S na tabela T, usando hashing linear para resolver colisões é mostrado abaixo.

Bruno Hott 20

Exemplo

h(L) = h(12) = 5, h(U) = h(21) = 0,h(N) = h(14) = 0, h(E) = h(5) = 5,h(S) = h(19) = 5.

Bruno Hott 21

Estrutura do Dicionário para Listas Encadeadas

#define M 7#define n 21 /* tamanho da chave */typedef char TipoChave[n];

typedef unsigned int TipoPesos[n];

typedef struct{ /* outros componentes */ TipoChave Chave;}TipoItem;

typedef unsigned int Indice;

Bruno Hott 22

Estrutura do Dicionário para Listas Encadeadas

typedef struct _celula* Apontador;

typedef struct _celula { TipoItem Item; Apontador Prox;}Celula;

typedef struct{ Celula *Primeiro, *Ultimo;} TipoLista;

typedef TipoLista TipoDicionario[M];

Bruno Hott 23

Operações do Dicionário Usando Listas Encadeadas

void Inicializa(TipoDicionario T){ int i; for (i = 0; i < M; i++) FLVazia(&T[i]);}

Bruno Hott 24


/* Apontador de retorno aponta para o item anterior da lista */Apontador Pesquisa(TipoChave Ch, TipoPesos p, TipoDicionario T){ Indice i; Apontador Ap; i = h(Ch, p); if (LEhVazia(T[i])) return NULL; /* Pesquisa sem sucesso */ else{ Ap = T[i].Primeiro; while ((Ap->Prox->Prox != NULL) && (strncmp(Ch, Ap->Prox->Item.Chave, sizeof(TipoChave)))) Ap = Ap->Prox;

if (!strncmp(Ch, Ap->Prox->Item.Chave, sizeof(TipoChave))) return Ap; else return NULL; /* Pesquisa sem sucesso */ }}

Bruno Hott 25


int Insere(TipoItem x, TipoPesos p, TipoDicionario T){ if(Pesquisa(x.Chave, p, T) == NULL){ Ins(&(T[h(x.Chave, p)],x)); return 1; } return 0;}

int Retira(TipoItem x, TipoPesos p, TipoDicionario T){ Apontador Ap; Ap = Pesquisa(x.Chave, p, T); if (Ap == NULL) return 0; Ret(&(T[h(x.Chave, p)]), Ap, &x); return 1;}

Bruno Hott 26

Análise

● Assumindo que qualquer item do conjunto tem igual probabi-lidade de ser endereçado para qualquer entrada de T, então o comprimento esperado de cada lista encadeada é N/M, onde N representa o número de registros na tabela e M o tamanho da tabela.

● Logo: as operações Pesquisa, Insere e Retira custam O(1 + N/M) operações em média, onde a constante 1 representa o tempo para encontrar a entrada na tabela e N/M o tempo para percorrer a lista.

● Para valores de M próximos de N, o tempo se torna constante, isto é, independente de N.

Bruno Hott 27

Estrutura do Dicionário Usando Endereçamento Aberto

#define Vazio "!!!!!!!!!!!!!!!!!!!!"#define Retirado "********************"#define M 7#define n 21 /* Tamanho da chave */

Bruno Hott 28


typedef unsigned int Apontador;typedef char TipoChave[n];typedef unsigned TipoPesos[n];

typedef struct{ /* outros componentes */ TipoChave Chave;}TipoItem;

typedef unsigned int Indice;typedef TipoItem TipoDicionario[M];

Bruno Hott 29


void Inicializa(TipoDicionario T){ int i; for (i = 0; i < M; i++) memcpy(T[i].Chave, Vazio, n);}

Bruno Hott 30


Apontador Pesquisa(TipoChave Ch, TipoPesos p, TipoDicionario T){ unsigned int i = 0; unsigned int Inicial;

Inicial = h(Ch, p); while ( (strcmp (T[(Inicial + i) % M].Chave, Vazio) != 0) && (strcmp (T[(Inicial + i) % M].Chave, Ch ) != 0) && (i < M) ) i++; if (strcmp (T[(Inicial + i) % M].Chave, Ch) == 0) return ((Inicial + i) % M); else return M; /* Pesquisa sem sucesso */}

Bruno Hott 31


int Insere(TipoItem x, TipoPesos p, TipoDicionario T){ unsigned int i = 0; unsigned int Inicial; if (Pesquisa(x.Chave, p, T) < M) return 0; Inicial = h(x.Chave, p); while ((strcmp(T[(Inicial + i) % M].Chave, Vazio) != 0) && (strcmp(T[(Inicial + i) % M].Chave, Retirado) != 0) && (i < M)) i++; if (i < M){ strcpy (T[(Inicial + i) % M].Chave, x.Chave); /* Copiar os demais campos de x, se existirem */ return 1; } else return 0;}

Bruno Hott 32


int Retira(TipoChave Ch, TipoPesos p, TipoDicionario T){ Indice i; i = Pesquisa(Ch, p, T); if (i == M) return 0; memcpy(T[i].Chave, Retirado, n); return 1;}

Bruno Hott 33

Análise

● Seja α = N/M o fator de carga da tabela. Conforme demonstrado por Knuth (1973), o custo de uma pesquisa com sucesso é

● O hashing linear sofre de um mal chamado agrupamento(clustering) (Knuth, 1973, pp.520–521).

● Este fenômeno ocorre na medida em que a tabela começa a ficar cheia, pois a inserção de uma nova chave tende a ocupar uma posição na tabela que esteja contígua a outras posições já ocupadas, o que deteriora o tempo necessário para novas pesquisas.

Bruno Hott 34

Análise - Clustering

Bruno Hott 35

Análise

● Entretanto, apesar do hashing linear ser um método relativamente pobre para resolver colisões os resultados apresentados são bons.

● O melhor caso, assim como o caso médio, é O(1).

Bruno Hott 36

Vantagens e Desvantagens de Transformações de Chaves

● Vantagens:– Alta eficiência no custo de pesquisa, que é O(1) para o caso médio.– Simplicidade de implementação

● Desvantagens:– Custo para recuperar os registros na ordem lexicográfica das chaves é

alto, sendo necessário ordenar o arquivo.– Pior caso é O(N)

aula 10a pesquisa: introdução · 2020-02-13 · bruno hott 2 introdução – conceitos básicos...

Documents