UNIVERSIDADE DA BEIRA INTERIOR

Transcrição

1 UNIVERSIDADE DA BEIRA INTERIOR Algoritmos e Estruturas de Dados - Bioengenharia 2º Semestre Frequência Resolução 19/maio/2015 A. [3.5 val] Algoritmos de ordenação e de pesquisa Considere-se as seguintes funções já construídas: int PesquisaSequencial (int k, int X[], int tam) devolve o índice de um elemento do vetor X, ordenado por ordem crescente, com valor igual a k (ou -1, caso não exista) void OrdenarFusao (int X[], int inicio, int fim) ordena o vetor X por ordem crescente Utilizando as funções dadas, resolva as questões que se seguem. 1. [1.5 val] Implementar uma função que devolva a soma dos elementos de um vetor X com N valores inteiros (pode haver elementos repetidos) que são maiores a um inteiro K (em que K está no vetor). Para tal, use o seguinte cabeçalho: int SomaElementosMaioresK (int X[], int N, int K) { int kk, pos, soma = 0; OrdenarFusao(X, 0, N-1); pos = PesquisaSequencial(K, X, N); kk = pos + 1; while ((kk < N) && (X[kk] == X[pos])) kk++; for (i = kk; i < N; i++) soma = soma + X[i]; return soma; 2. [2.0 val] Implementar uma função que remova o k-ésimo menor elemento de um dado vetor X com N valores inteiros não repetidos, utilizando memória dinâmica. Para tal use o seguinte cabeçalho: int *Removerk_MenorElemento (int k, int X[], int *N) { int i; OrdenarFusao(X, 0, *N-1); for (i = k-1; i < *N-1; i++) X[i] = X[i+1]; *N = *N 1; X = (int *) realloc (X, (*N) * sizeof(int)); return X;

2 B. [2.0 val] Recursividade Implementar uma função recursiva que dado um vetor V com N valores reais, determine a soma dos elementos de V que são menores ou iguais a um dado valor real Y. float somamenoresiguais (float X[], int N, float Y) { if (N == 0) return 0; if (X[N-1] <= Y) return somamenoresiguais(x, N-1, Y) + X[N-1]; return somamenoresiguais(x, N-1, Y); C. [1.0 val] Análise de complexidade dos algoritmos Determine e justifique (apresentando os cálculos efetuados) a ordem de complexidade do algoritmo (considerando o pior caso) cujo bloco de código base é o seguinte:... cont = 0; for (i = 1; i <= 20; i++) for (j = i; j <= n; j++) cont = cont + 1;... Sugestão: calcule o número de vezes que a instrução cont = cont + 1 é executada Determinar o número de vezes que a instrução cont = cont + 1 (A) é executada. i = 1; j = 1, 2,, n ===> A é executada n vezes i = 2; j = 2, 3,, n ===> A é executada (n-1) vezes i = 3; j = 3, 4,, n ===> A é executada (n-2) vezes i = 19; j = 19,, n ===> A é executada (n-18) vezes i = 20; j = 20,, n ===> A é executada (n-19) vez Logo, A é executada n + (n-1) + (n-2) (n-18) + (n-19) vezes. Assim sendo, e como esta expressão traduz uma progressão aritmética, A é executada ((n + n - 19) / 2) x 20 = (2 n - 19) x 10 = 20 n vezes. Logo, o bloco que código tem ordem de complexidade linear O(n).

3 D. [2,0 val] Tabelas de dispersão/hash Considere uma tabela de hash T de tamanho 10 inicialmente vazia e a função de hash seguinte: h(k, i) = (k + i 3 ) % 10, com i = 0, 1, 2, Considerando que as colisões são tratadas com hashing fechado, desenhe uma tabela de hash após a inserção das seguintes chaves (pela ordem apresentada): 56, 22, 65, 77, 46 e 24. Justifique apresentando os cálculos efetuados. h(56, 0) = ( ) % 10 = 56 % 10 = 6 h(22, 0) = ( ) % 10 = 22 % 10 = 2 h(65, 0) = ( ) % 10 = 65 % 10 = 5 h(77, 0) = ( ) % 10 = 77 % 10 = 7 h(46, 0) = ( ) % 10 = 46 % 10 = 6 (colisão com a chave 56) h(46, 1) = ( ) % 10 = 47 % 10 = 7 (colisão com a chave 77) h(46, 2) = ( ) % 10 = 54 % 10 = 4 h(24, 0) = ( ) % 10 = 24 % 10 = 4 (colisão com a chave 46) h(24, 1) = ( ) % 10 = 25 % 10 = 5 (colisão com a chave 65) h(24, 2) = ( ) % 10 = 32 % 10 = 2 (colisão com a chave 22) h(24, 3) = ( ) % 10 = 51 % 10 = 1 A tabela fica da seguinte forma: T Desenhe a tabela após a remoção da chave 56. Justifique apresentando os cálculos efetuados. h(56, 0) = ( ) % 10 = 56 % 10 = 6 T[6] = 56, logo 56 é removido de T, mas T[6] fica com o rótulo de Removido (livre mas já ocupado). A tabela fica então da seguinte forma: T Verifique que a chave 15 não se encontra na tabela. Justifique apresentando os cálculos. h(15, 0) = ( ) % 10 = 15 % 10 = 5 T[5] = 65. Como T[5] está ocupado com uma chave que não é 15, nada se pode concluir acerca da existência da chave 15 na tabela T, pelo que se deve procurar a próxima posição possível desta chave na tabela T. h(15, 1) = ( ) % 10 = 16 % 10 = 6 T[6] está vazia, mas com rótulo de Removido (já foi ocupado antes). Logo, como nada se pode concluir acerca da existência da chave 15 na tabela T, deve-se procurar a próxima posição possível desta chave na tabela T. h(15, 2) = ( ) % 10 = 23 % 10 = 3 T[3] está livre (vazia e nunca ocupada). Logo, pode-se concluir da não existência da chave 15 na tabela T. Resposta: 15 não pertence à tabela T.

4 E. [2,0 val] Listas ligadas Considere as declarações de Nodo e PNodo (adaptada dos apontamentos) seguintes: struct Nodo { int Elemento; struct Nodo *Prox; ; typedef struct Nodo *PNodo; e a função já implementada seguinte: PNodo ProcurarAnterior (PNodo L, int E); // devolve um ponteiro para o nodo anterior ao nodo com o valor E Construa um bloco de código em C que, usando a função dada em cima e apenas 4 ponteiros auxiliares, troque o nodo com o valor X com o nodo com o valor Y, os quais pertencem às listas ligadas (com ligações simples) L1 e L2 respetivamente (ver figura seguinte). Resolução 1: P1 = ProcurarAnterior(L1, X); P2 = P1 Prox Prox; Q1 = ProcurarAnterior(L2, Y); Q2 = Q1 Prox; P1 Prox Prox = Q2 Prox; Q1 Prox = P1 Prox; Q2 Prox = P2; P1 Prox = Q2; Resolução 2: P1 = ProcurarAnterior(L1, X); P2 = P1 Prox; Q1 = ProcurarAnterior(L2, Y); Q2 = Q1 Prox; P1 Prox = P2 Prox; Q1 Prox = Q2 Prox; Q2 Prox = P1 Prox; P1 Prox = Q2; P2 Prox = Q1 Prox; Q1 Prox = P2;

5 F. [1,5 val] Pilhas Considere as declarações de Nodo e PNodo (adaptada dos apontamentos) seguintes: struct Nodo { int Elemento; struct Nodo *Ant; ; typedef struct Nodo *PNodo; e as operações associadas à Estrutura Abstrata de Dados Pilha seguintes: PNodo Criar (); int Vazia (PNodo S); PNodo Push (int X, PNodo S); PNodo Pop (PNodo S); int Topo (PNodo S); Usando a definição de pilha de inteiros em cima, implemente uma função que dada uma pilha S, determine e devolva o k-ésimo elemento a partir do topo da pilha, usando o seguinte cabeçalho: int DeterminarElementoFundo (PNodo S, int k) { int i, kk, aux; kk = 1; // existe k-ésimo elemento for (i = 1; i < k && kk == 0; i++) if (!Vazia(S)) { aux = Topo(S); Pop(S); kk = 1; if (kk == 0) return Topo(S); return aux;