Carlos Eduardo Batista. Centro de Informática - UFPB

Transcrição

1 Estrutura de Dados Carlos Eduardo Batista Centro de Informática - UFPB bidu@ci.ufpb.br

2 Métodos de pesquisa e classificação de dados (continuação) Estruturas de Dados 2

3 Algoritmo de busca Recebe como argumento o índice para a busca e o conjunto no qual a busca será realizada Conjunto de dados Um vetor de registros Uma lista encadeada Uma árvore Busca Sequencial Binária Busca por interpolação, em árvores e hashing Busca deve ser realizada com menor custo Utilizar menor quantidade de recursos possíveis 3

4 Busca sequencial Forma mais simples Aplica-se a vetores, listas encadeadas e estruturas que possuem sequência de ordenação São consultados todos os registros até que se encontre o que se busca Encontrar 988 em um vetor com 8 elementos inteiros Iteração ª. Iteração! 4

5 int A[] = { 234, 567, 353, 276, 958, 598, 988, 544 }; int x = 988; for (i=0; i<8; i++) { if (A[i] == x) return(i); /*chave encontrada*/ } return(-1); /* chave não encontrada */ A int A[] = { 234, 567, 353, 276, 958, 598, 988, 544 }; int x = 988; int i; int n = 8; A[n] = 988; for (i=0; x!=a[i]; i++) if (i < n) return(i); /*chave encontrada*/ else return(-1); /*chave não encontrada*/ B 5

6 Busca sequencial Tamanho fixo do vetor Desperdício de memória pode ocorrer Alternativa: usar lista encadeada Complexidade Pesquisa com sucesso melhor caso: O(1) pior caso: O(n) caso médio: O((n+1) / 2) Pesquisa sem sucesso O(n) 6

7 Busca sequencial Em estrutura ordenada (pelos valores das chaves a serem buscadas) Melhor eficiência Pior caso (não encontrada a chave): O(n) Caso médio: O(n/2) Tabela de índices 7

8 Chave Registro

9 Busca binária Se os dados estiverem ordenados em um arranjo... Arr[i] <= Arr[i+1] (ordem crescente) Arr[i] >= Arr[i+1] (ordem decrescente) Parte-se do elemento do meio do arranjo para realizar a busca Se igual, busca bem sucedida Se maior ou menor, realizar busca na metade correspondente (dependendo se ordenado crescente ou decrescentemente) 9

10 Buscando < = 133 Elemento encontrado! 10

11 Busca binária Complexidade O(log n) cada comparação reduz o número de possíveis candidatos por um fator de 2 Eficiente e simples Porém... Nem todo arranjo está ordenado Faz uso do fato que os índices são inteiros consecutivos Não se aplica a todos os tipos de estruturas Pode-se combinar com busca sequencial (organização da tabela secundária) 11

12 struct registry { int id; /* chave do registro */... /* outros campos do registro */ } typedef struct registry Registry; 12

13 /* tamanho do vetor = n */ /* função retorna posição do registro no vetor v, ou -1 se não encontrou */ int binsearch(registry *v, int id) { if (n <= 0) return -1; int esq = 0; int dir = n - 1; int i; do { i = (esq + dir) / 2; if (id > v[i].id) esq = i + 1; else dir = i - 1; } while ((id!= v[i].id) && (esq <= dir)); if (id == v[i].id) return i; return -1; } 13

14 Ordenação (Classificação) Rearranjar um conjunto de objetos Ordem ascendente ou descendente Ordenação interna Tudo na memória principal Seleção Inserção QuickSort MergeSort Ordenação externa QuickSort externo Intercalação balanceada 14

15 Ordenação Facilitar a recuperação de itens do conjunto ordenado Registros e chaves Regra de ordenação Comparação de chaves Ordenação por distribuição 15

16 Ordenação interna Complexidade Número de comparação entre chaves Número de movimentações entre itens Usar memória com parcimônia sempre Métodos simples Pequeno volume de informações O(n 2 ) Métodos eficientes Menos comparações O(n log n) 16

17 Ordenação por seleção Algoritmo simples Seleciona-se o menor item do vetor Troca-se com o item da primeira posição do vetor Repetir com n-1 restantes, depois n-2... Até que reste apenas um elemento (n 2 /2) (n/2) comparações 3(n-1) movimentações de registro 17

18 Ordenação por seleção 18

19 typedef int Indice; typedef Item Vetor[MaxTam + 1]; Vetor A; void selecao(item *A, Indice *n) { Indice i, j, Min; Item x; for (i = 1; i <= *n - 1; i++) { Min = i; for (j = i + 1; j <= *n; j++) if (A[j].Chave < A[Min].Chave) Min = j; x = A[Min]; A[Min] = A[i]; A[i] = x; } } 19

20 Ordenação por seleção Utilizado para ordenar conjuntos com registro grandes ou poucos registros Ordenação prévia (ou semi-ordenação) não ajuda em nada Algoritmo não é estável 20

21 Ordenação por inserção Em cada passo a partir do 2º (i=2), faça Selecione o i-ésimo item da sequência fonte Coloque-o no lugar correto (de acordo com o critério de ordenação) na sequência destino O processo de ordenação termina quando Um item com chave menor que o item em consideração é encontrado O final da sequência destino é atingido a esquerda Usa-se um sentinela na posição 0 do vetor 21

22 22

23 void insercao(item *A, Indice *n) { Indice i, j; Item x; for (i = 2; i <= *n; i++) { x = A[i]; j = i - 1; A[0] = x; /* sentinela */ while (x.chave < A[j].Chave) { A[j + 1] = A[j]; j--; } A[j + 1] = x; } } 23

24 Ordenação por inserção O número mínimo de comparações ocorre quando os registros já estão ordenados O número máximo de comparações ocorre quando os registros estão na ordem reversa Método a ser utilizado quando o conjunto está quase ordenado Algoritmo estável 24

25 Quicksort Mais rápido para um grande leque de possibilidades Dividir para conquistar Problemas menores são ordenados separadamente, resultado é combinado Vetor é rearranjado a partir de um pivô Processo de partição A parte esquerda com chaves menores ou iguais ao pivô. A parte direita com chaves maiores ou iguais ao pivô. 25

26 Particionamento Escolha do pivô (x) Percorre-se o vetor a partir da esquerda até que o valor seja maior ou igual ao pivô V[i] >= x Percorre-se o vetor a partir da direita até que o valor seja menor igual ao pivô V[j] <= x Troca-se V[i] e V[j] Continuar o processo até que i e j se cruzem 26

27 Particionamento Vetor V estará particionado de forma que V[esq], V[esq+1]..., V[j] são menores ou iguais ao pivô (x) V[i], V[i+1],..., V[dir] são maiores ou iguais ao pivô (x) 27

28 28

29 typedef struct { Indice Esq, Dir; } TipoItem; void QuickSort_NaoRec(Item *A, Indice *n) { TipoPilha Pilha; Indice Esq, Dir, i, j; TipoItem Item; FPvazia(Pilha); Esq = 1; Dir = *n; Item.Dir = Dir; Item.Esq = Esq; Empilha(Item, Pilha); repeat if (Dir > Esq) { Particao(Esq, Dir, &i, &j, A); Item.Dir = Dir; Item.Esq = i; Empilha(Item, Pilha); Dir = j; } else { } } while (!Vazia(Pilha)); } Desempilha(Pilha, Item); Dir = Item.Dir; Esq = Item.Esq; 29

30 void particao(indice Esq, Indice Dir, Indice *i, Indice *j, Item *A) { Item x, w; *i = Esq; *j = Dir; x = A[(*i + *j) / 2]; /* obtem o pivo x */ do { while (x.chave > A[*i].Chave) (*i)++; while (x.chave < A[*j].Chave) (*j)--; if ((*i) (*j)) { w = A[*i]; A[*i] = A[*j]; A[*j] = w; (*i)++; (*j)--; } }while (*i <= *j); } 30

31 void qordena(indice Esq, Indice Dir, Item *A) { particao(esq, Dir, &i, &j, A); if (Esq < j) qordena(esq, j, A); if (i < Dir) qordena(i, Dir, A); } void quicksort(item *A, Indice *n) { qordena(1, *n, A); } 31

32 32

33 Eficiente para situações genéricas Requer em média n log n comparações para n itens Pior caso O(n 2 ) Método não estável 33

34 Listas, Pilhas e Filas Próximas aulas 34

35 Notas de Aula do Prof. Bruno B. Boniati Notas de Aula do Prof. João Luís Garcia Rosa s/ Referências 35

36 Estrutura de Dados Carlos Eduardo Batista Centro de Informática - UFPB bidu@ci.ufpb.br