UNIVERSIDADE DA BEIRA INTERIOR

Transcrição

1 UNIVERSIDADE DA BEIRA INTERIOR Algoritmos e Estruturas de Dados - Bioengenharia 2º Semestre Exame Especial Resolução 19/07/2013 A. [4.75 val] Algoritmos de ordenação e de pesquisa (usando memória estática - vetores) Considere a seguinte definição de estrutura: typedef struct { char ISBN[20]; char Titulo[80]; char Editora[20]; int Desconto; float Preco; int stock; LIVROS; e que as seguintes funções estão implementadas: void OrdenaBubblesortLivroPreco(LIVROS *L, int tam) // ordena crescentemente pelo Preço void OrdenaBubblesortLivroDesconto(LIVROS *L, int tam) // ordena crescentemente por Desconto void OrdenaBubblesortLivroStock(LIVROS *L, int tam) // ordena crescentemente pelo Stock int PesquisaSequencialLivroPreco(float prc, LIVROS *L, int tam) // devolve o índice de um livro cujo preço é prc, ou -1 caso não exista int PesquisaSequencialLivroDesconto(int desc, LIVROS *L, int tam) // devolve o índice de um livro cujo desconto é desc, ou -1 caso não exista int PesquisaSequencialLivroStock(int stck, LIVROS *L, int tam) // devolve o índice de um livro cujo stock é stck, ou -1 caso não exista Na implementação das funções seguintes deve apresentar versões o mais otimizadas possíveis e usar, sempre que possível, as funções já implementadas. Deve também usar as que implementar antes. 1. Implemente a seguinte função para remover todos os livros da lista L com o preço mais elevado: LIVROS *RemoverLivrosMaiorPreco (LIVROS *L, int *tam) LIVROS *RemoverLivrosMaiorPreco (LIVROS *L, int *tam) { int k; OrdenaBubblesortLivroPreco(L, *tam); k = PesquisaSequencialLivroPreco(L[*tam-1].Preco, L, *tam); L = (LIVROS *) realloc(l, (k+1) * sizeof(livros)); *tam = k + 1; return L;

2 2. Implemente a seguinte função para determinar o preço médio dos livros da lista L com maior desconto: float PrecoMedioLivrosMaiorDesconto (LIVROS *L, int tam) float PrecoMedioLivrosMaiorDesconto (LIVROS *L, int tam) { int k, i, cont; float soma = 0; OrdenaBubblesortLivroDesconto(L, tam); k = PesquisaSequencialLivroDesconto(L[tam-1].Desconto, L, tam); for (i = k; i < tam; i++) soma = soma + L[i].Preco; cont = tam k; return (soma / cont); 3. Implemente a seguinte função para determinar o número de livros da lista L com menor stock: int NumeroLivrosMenorStock (LIVROS *L, int tam) int NumeroLivrosMenorStock (LIVROS *L, int tam) { int k, cont = 0; OrdenaBubblesortLivroStock(L, tam); k = 0; while (k < tam && L[k].Stock == L[0].Stock) cont++; return (cont); B. [1.25 val] Recursividade Implemente a seguinte função recursiva para determinar a soma dos números pares entre os inteiros K1 e K2 (com K1 < k2): int SomaParesDeK1aK2 (int K1, int K2) int SomaParesDeK1aK2 (int K1, int K2) { if (K1 == K2) if (K2 % 2 == 0) return k2; else return 0; if (K2 % 2 == 0) return (K2 + SomaParesDeK1aK2(K1, K2-1)); else return (SomaParesDeK1aK2(K1, K2-1));

3 C. [1.0 val] Análise de complexidade dos algoritmos Determine e justifique a ordem de complexidade do algoritmo (considerando o pior caso) cujo bloco de código base é o seguinte:... soma = 0; for (i = 0; i < n; i++) for (j = i; j <= i; j++) soma = soma + X[i][j];... Como se pretende analisar o pior caso, vai-se determinar o número de vezes que a instrução que mais vezes é executada (j <= i): i = 0 j = 0 (0 <= 0)? Sim ==> 1 vez j = 1 (1 <= 0)? Não ==> 1 vez i = 1 j = 1 (1 <= 1)? Sim ==> 1 vez j = 2 (2 <= 1)? Não ==> 1 vez i = 2 j = 2 (2 <= 2)? Sim ==> 1 vez j = 3 (3 <= 2)? Não ==> 1 vez... i = n-1 j = n-1 (n-1 <= n-1)? Sim ==> 1 vez j = n (n <= n-1)? Não ==> 1 vez Portanto, no total a instrução é executada o seguinte número de vezes: = 2 x (de 0 até n-1 = n) = 2 x n = 2xn Logo, este algoritmo tem ordem de complexidade n O(n). 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) = (k + 2) % 10 a) Considerando que as colisões são tratadas com hashing aberto, desenhe uma tabela de hash após a inserção das seguintes chaves (pela ordem apresentada): 15, 87, 43, 65, 23, 85 e 90. Justifique apresentando os cálculos efetuados.

4 h(15) = 17 % 10 = 7 h(87) = 89 % 10 = 9 h(43) = 45 % 10 = 5 h(65) = 67 % 10 = 7 h(23) = 25 % 10 = 5 h(85) = 87 % 10 = 7 h(90) = 92 % 10 = 2 A tabela fica da seguinte forma: T b) Desenhe a tabela após a remoção da chave 65. Justifique apresentando os cálculos efetuados. h(65) = 67 % 10 = 7 Como 65 está na sublista T[7], vai-se remover este elemento desta sublista. A tabela fica da seguinte forma: T c) Verifique se a chave 75 se encontra na tabela. Justifique apresentando os cálculos efetuados. h(75) = 77 % 10 = 7 Como 75 não está na sublista T[7], conclui-se que 75 não pertence à tabela T (75 T). E. [5.0 val] Listas ligadas 1. A figura que se segue representa uma lista com ligações duplas. a) Indique as operações necessárias à remoção do último elemento da lista (E4) e a respetiva ordem pela qual se realizam.

5 b) Indique como traduz em linguagem C cada uma das operações identificadas na alínea a). 1 => PAux = Tail // PAux aponta para E4; logo, Paux Anterior aponta para E3 2 => Tail = Tail Anterior // Tail aponta para E3 3 => Tail Proximo = NULL 4 => PAux Anterior = NULL 5 => free(paux) 2. Considere uma lista L de ligações simples cujos elementos são valores inteiros. Implemente a seguinte função para determinar o valor médio dos elementos de L: float MediaLista (PNodo L) float MediaLista (PNodo L) { PNodo P = L; int soma = 0, cont = 0; while (P!= NULL) { soma = soma + P Elemento; cont++; P = P Proximo; return (float) (soma/cont); 3. Considere uma lista L de ligações simples cujos elementos são valores inteiros e a seguinte função já implementada: PNodo ProcurarAnterior (PNodo L, int E); // devolve o nodo anterior ao nodo que contém E Implemente a seguinte função para remover todos os nodos entre os nodos que contêm os elementos X e Y, inclusivé: PNodo RemoverNodos (int X, int Y, PNodo L) Nota: remover todos os nodos entre os nodos que contêm os elementos X e Y (ver desenho) PNodo RemoverNodos (int X, int Y, PNodo L) { // assumir que X está antes de Y PNodo PAntX, PAntY, PY, PX, P; if (L == NULL) return L; PAntX = ProcurarAnterior(L, X); // PAntX aponta para H (se X é o primeiro, PAntX é NULL) PAntY = ProcurarAnterior(L, Y); // PAntY aponta para M PY = PAntY Proximo; // PY aponta para Y

6 if (PAntX == NULL) { // X é o primeiro elemento de L PX = L; L = PY Proximo; else { // caso geral PX = PAntX Proximo; PAntX Proximo = PY Proximo; // libertar os nodos removidos while (PX!= PY) { P = PX; PX = PX Proximo; P Proximo = NULL; free(p); return L; 4. Considere a seguinte EAD Fila Q: Determine o valor das operações sobre a Fila Q, desenhando o estado que esta apresenta após a realização de cada uma das seguintes operações (independentes entre si): a) Frente(Juntar(X, Q)) Frente(Juntar(X, Q)) = Frente(Juntar(X, [E1, E2, E3, E4])) = Frente([E2, E3, E4, X]) = E2 b) Remover(Remover(Q)) Remover(Remover(Q)) = Remover(Remover([E1, E2, E3, E4])) = Remover([E2, E3, E4]) = = [E3, E4] c) Juntar(Y, Juntar(X, Remover(Q))) Juntar(Y, Juntar(X, Remover(Q)) = Juntar(Y, Juntar(X, Remover([E1, E2, E3, E4])) = = Juntar(Y, Juntar(X, [E2, E3, E4])) = Juntar(Y, [E2, E3, E4, X])= [E2, E3, E4, X, Y]

7 5. 5. Estrutura Abstrata de Dados Árvore Binária a) Considere a seguinte EAD Arvore Binária T. Percorra T em pós-ordem (esquerda, direita, raíz) b) Construa uma EAD Árvore Binária T de altura 3 cuja travessia em pós-ordem é a seguinte: