UNIVERSIDADE DA BEIRA INTERIOR

Transcrição

1 UNIVERSIDADE DA BEIRA INTERIOR Programação II 1º Semestre Frequência 2 Resolução 07/01/ [1,25 val] - Análise de Complexidade dos Algoritmos Considere o seguinte bloco de código em linguagem C: for (p = 0; p < 10; p++){ for (k = 0; k < N; k++) printf( %d\n, k); Determine a ordem de complexidade do algoritmo (considerando o pior caso) associado ao bloco de código anterior. Justifique, apresentando todos os cálculos efetuados. Pode incidir os cálculos sobre a operação que mais vezes é executada, que é a instrução de comparação k < N. Basta determinar o número de vezes que a instrução de comparação k < N (A) é executada, pois é a mais vezes executada. p = 0 (p < 10 verdadeiro) k = 0, 1,,, N-1 (k < N verdadeiro), N (k < N falso) ==> A é executada N+1 vezes p = 1 (p < 10 verdadeiro) k = 0, 1,, N-1 (k < N verdadeiro), N (k > N falso) ==> A é executada N+1 vezes p = 9 (p < 10 verdadeiro) k = 0, 1,, N-1 (k < N verdadeiro), N (k < N falso) ==> A é executada N+1 vezes p = 10 (p < 10 falso) k não assume qualquer valor ==> A é executado 0 vezes Assim sendo, A é executada, no total, as seguintes vezes: (N+1) [p=0] + (N+1) [p=1] + + (N+1) [p=9] = 10 x (N+1) = 10 x N + 10 Logo, a função dada tem ordem de complexidade O(N) => Linear. 1

2 2. [1,25 val + 0,25 val + 0,50 val + 0,50 val] - Tabelas de Dispersão/Hash Considere uma tabela de hash T de tamanho 10 inicialmente vazia e a seguinte função de hash: h(k, i) = ( k % 10 + i 2 ) % 10, i = 0, 1, 2,... Responda às questões que se seguem, justificando com os cálculos que são necessários efetuar. a) Considerando que as colisões são tratadas com hashing fechado, desenhe a tabela de hash T após a inserção das seguintes chaves (pela ordem apresentada): 70, 85, 39, 24, 14 e 30. h(70, 0) = ((70 % 10) ) % 10 = (0 + 0) % 10 = 0 h(85, 0) = ((85 % 10) ) % 10 = (5 + 0) % 10 = 5 h(39, 0) = ((39 % 10) ) % 10 = (9 + 0) % 10 = 9 h(24, 0) = ((24 % 10) ) % 10 = (4 + 0) % 10 = 4 h(14, 0) = ((14 % 10) ) % 10 = (4 + 0) % 10 = 4 (colisão com 24) h(14, 1) = ((14 % 10) ) % 10 = (4 + 1) % 10 = 5 (colisão com 85) h(14, 2) = ((14 % 10) ) % 10 = (4 + 4) % 10 = 8 % 10 = 8 h(30, 0) = ((30 % 10) ) % 10 = (0 + 0) % 10 = 0 (colisão com 70) h(30, 1) = ((30 % 10) ) % 10 = (0 + 1) % 10 = 1 T b) Redesenhe a tabela anterior após a remoção da chave 39. h(39, 0) = ((39 % 10) ) % 10 = (9 + 0) % 10 = 9 Como T[9] = 39 = 39 (elemento a remover), então remover 39 da tabela T, mas T[9] fica com o rótulo de Removido (livre mas já ocupado). T

3 c) Prove que a chave 48 não se encontra na tabela anterior. h(48, 0) = ((48 % 10) ) % 10 = (8 + 0) % 10 = 8 Como a posição T[8] = (elemento a pesquisar), então nada se pode concluir e a pesquisa deve continuar. h(48, 1) = ((48 % 10) ) % 10 = (8 + 1) % 10 = 9 Como a posição T[9] está vazia, mas como já foi ocupada (rotulada de Removida), então nada se pode concluir e a pesquisa deve continuar. H(48, 2) = ((48 % 10) ) % 10 = (8 + 4) % 10 = 12 % 10 = 2 Como a posição T[2] está vazia e nunca foi ocupada (rotulada de Livre), então pode-se concluir que a chave 48 não está na tabela T. d) Insira a chave 48 na tabela obtida em b) (ou seja, após remoção da chave 39). h(48, 0) = ((48 % 10) ) % 10 = (8 + 0) % 10 = 8 (colisão com 14) h(48, 1) = ((48 % 10) ) % 10 = (8 + 1) % 10 = 9 (posição vazia) Logo, T[9] = 48. T

4 3. [2,00 val + 2,25 val] - Algoritmos de Ordenação e de Pesquisa Considere a seguinte definição de um tipo estrutura associada aos dados de uma pessoa: typedef struct { int numcc; // Número de Cartão de Cidadão (único) float altura; // Altura em metros (exemplo: 1.85) int peso; // Peso em Kg (exemplo: 76) PESSOA; Considere as seguintes funções (já implementadas): void OrdenarPeso (PESSOA V[], int tam); // ordena crescentemente o vetor V pelo campo peso int PesquisaBinariaPeso (int P, PESSOA V[], int N); // devolve o índice de um elemento de V cujo campo peso é igual a P ou -1 (se não existe qualquer elemento), em que V está ordenado por ordem crescente do campo peso a) Usando a função OrdenarPeso, implemente uma função em C que dados como parâmetros da função um vetor do tipo PESSOA não ordenado e o seu tamanho (número de elementos), remova todos os elementos daquele vetor com o maior valor do campo peso. PESSOA *RemoverElementosMaiorPeso (PESSOA V[], int *N) { int k, cont; OrdenarPeso(V, *N); // ordem crescente pelo campo peso // os maiores elementos estão nas últimas posições/índices do vetor cont = 1; // existe pelo menos um elemento com o peso máximo k = *N - 2; // k = penúltimo índice de V o último já foi contabilizado) while (k >= 0 && V[k].peso == V[*N-1].peso) { k--; // cont = número de elementos de V com peso máximo // atualizar o tamanho de V (não contar com os cont elementos com peso máximo) e // remover os cont elementos de V com peso máximo (os últimos) *N = *N cont; // atualizar o tamanho V = (PESSOA *) realloc(v, (*N)*sizeof(PESSOA)); // remover os elementos return V;

5 b) Usando as funções OrdenarPeso e PesquisaBinariaPeso, implemente uma função em C que dados como parâmetros da função um vetor do tipo PESSOA, o seu tamanho (número de elementos) e dois valores P (inteiro) e A (real), determine e devolva a quantidade de elementos do vetor cujo valor do campo peso é igual a P e cujo valor do campo altura é maior ou igual a A. int NumeroElementosComPesoPAlturaA (PESSOA V[], int N, int P, float A) { int k, pos, cont; OrdenarPeso(V, N); // ordem crescente pelo campo peso pos = PesquisaBinariaPeso(P, V, N); if (pos == -1) return 0; // não existem elementos em V com peso igual a P cont = 0; // percorrer todos os elementos como pesos iguais a P que têm índice maior ou igual a pos k = pos; while (k < N && V[k].peso == P) { if (V[k].altura >= A) // percorrer todos os elementos como pesos iguais a P que têm índices menores que pos k = pos 1; while (k >= 0 && V[k].peso == P) { if (V[k].altura >= A) return cont; NOTA: As funções OrdenarPeso e PesquisaBinariaPeso devem ser usadas de tal forma que sejam fundamentais na resolução dos problemas e que otimizem os algoritmos (com o menor número de operações possível). 5