Primeira Lista de Exercícios – EDA 2019.

1. Faça um algoritmo para encontrar todos os elementos comuns em duas listas de

números inteiros. As listas estão ordenadas. Por exemplo, considere as listas L1 = {2, 5,
5, 5} e L2 = {2, 2, 3, 5, 5, 7}. A saída do seu algoritmo deve ser L3 = {2, 5, 5}. Qual é o
maior número de comparações que seu algoritmo faz se os comprimentos das listas forem
m e n?

2. Descreva como as seguintes operações podem ser realizadas em uma lista representada
em alocação sequencial:
a. Remover o i-ésimo elemento de uma lista não ordenada.
b. Remover o i-ésimo elemento de lista ordenada. A lista deve permanecer ordenada após
a remoção.

3. Faça um algoritmo para encontrar o máximo e o mínimo de uma lista não ordenada
representada em alocação sequencial. Qual é o maior número de comparações que seu
algoritmo faz se o comprimento da lista for n?

4. Calcule a complexidade de pior caso da busca binária onde A é uma lista de n inteiros,
a e b delimitam a parcela da lista onde a busca é feita, e x é a chave de busca. Inicialmente,
a = 1 e b= n.

buscabin(A: vetor[1..n] de inteiros; a, b: inteiro; x: inteiro)

se a > b então retorne(0)
senão
mid (a + b)/2
se x = A[mid] então retorne(mid)
senão se x < A[mid] então retorne(buscabin(a, mid - 1))
senão retorne(buscabin(mid + 1, b)

5. Mostre que a afirmativa é verdadeira ou justifique porque é falsa:

a) 2n+1 é O(2n);
b) 25n é O(2n);
c) n é O(n2);
d) n2 – n é O(n2);

6. Refaça o exercício 5 com Ω em lugar de O.

7. Considere os algoritmos Fácil e Simples, verifique as afirmativas verdadeiras.

I. O algoritmo Fácil é O(n).

II. O algoritmo Fácil é Ω(n).
III. O algoritmo Simples é O(n).

a) Apenas a afirmativa I está correta.

b) Apenas a afirmativa II está correta.
c) Apenas a afirmativa III está correta.
d) Apenas as afirmativas I e III estão corretas.
e) Todas as afirmativas estão corretas.
 Algoritmo Fácil Algoritmo Simples
Entrada: { tab: vetor [1 ... n] de inteiros } Entrada: { x: inteiro, tab: vetor [1 ... n] de
1. x ← tab[1]; inteiros }
2. para i de 2 até n faça 1. i ← 0;
3. se x ≤ tab[i] então x ← tab[i]; 2. z ← 0;
4. escreva(x); 3. repita
4. i ← i + 1;
5. se x = tab[i] então z ← 1;
6. até z = 1 ou i = n;
7. se z = 1 então f = i;
8. escreva(f);

8. Dada uma matriz, A, quadrada de ordem n, e uma matriz linha U com n elementos, faça
um algoritmo que verifique se alguma linha de A é igual a U. Analise a complexidade do
seu algoritmo.

9. Analise a complexidade local do algoritmo UI.

Algoritmo UI
Entrada: { S,T: conjuntos de n de inteiros }
1. U ← S;
2. I ← Ø;
3. para cada x  T faça
4. se x  S
5. então Insere(x,I)
6. senão Insere(x,U)

10. Analise a complexidade local do algoritmo MS.

Algoritmo MS
Entrada: { A, B: matrizes de inteiros de ordem n }
1. s ← 0;
2. m ← 0;
3. para i de 1 até n faça
4. s ← s + A[1,j] + B[1,j];
5. m ← s;
6. para i de 2 até n faça
7. s ← 0;
8. para j de 1 até n faça
9. s ← s + A[i,j] + B[i,j];
10. se s > m então m ← s;
11. escreva(m);

11. Faça um algoritmo que leia um arquivo com n pares pi = (ai,bi) de inteiros. O
algoritmo deve gerar uma lista dos pares não dominados entre si. Um par pi domina um
outro pj se (ai  aj  bi  bj)  (ai < aj  bi < bj). Analise a complexidade local do seu
algoritmo.