PCS - 3110 Algoritmos e Estrutura de Dados para a Engenharia Eltrica

2 Prova 14 de Outubro de 2014 - Gabarito

Questo 1 (3,0 pontos):
Deseja-se implementar o algoritmo de ordenao Mergesort, mas dividindo a sequncia em 3 partes iguais
(ao invs de 2 do algoritmo tradicional).
a) (1,0 ponto)
Complete o algoritmo que intercala 3 vetores (Intercala-3), onde inicio1 a posio do 1 elemento do 1
subvetor e fim1, fim2 e fim3 so as posies do ltimo elemento do 1, 2 e 3 subvetor, respectivamente.
Intercala-3(A, inicio1, fim1, fim2, fim3)
1 n1 = fim1 incio1 + 1
2 n2 = fim2 fim1
3 n3 = fim3 fim2
4 seja V1[1..n1 + 1], V2[1..n2 + 1] e V3[1..n3 + 1] novos vetores
5 // Copiando os valores aos vetores
6 for i = 1 to n1
7
V1[i] = A[incio1 + i 1]
8 for i = 1 to n2
9
V2[i] = A[fim1 + i]
10 for i = 1 to n3
11 V3[i] = A[fim2 + i]
12 V1[n1 + 1] =
13 V2[n2 + 1] =
14 V3[n3 + 1] =
15 i1 = 1
16 i2 = 1
17 i3 = 1
18 for j = incio1 to fim3
19

if V1[i1] <= V2[i2] and V1[i1] <= V3[i3]

20

A[j] = V1[i1]

21

i1 = i1 + 1

22

else if V2[i2] <= V3[i3]

23

A[j] = V2[i2]

24

i2 = i2 + 1

25 else A[j] = V3[i3]

26

i3 = i3 + 1

PCS - 3110 Algoritmos e Estrutura de Dados para a Engenharia Eltrica

b) (0,3 ponto)
Qual a complexidade de Intercala-3 em termos de n1, n2 e n3 ?
(n1 + n2 + n3)

c) (0,7 ponto)
Complete o algoritmo Mergesort-3-Partes. Chame o algoritmo Intercala-3 para intercalar os 3 vetores.
Use a varivel umTero, a qual contm aproximadamente 1/3 do tamanho do vetor (por exemplo, para um
subvetor de tamanho 8, umTero conter 3).
Mergesort-3-Partes(A, inicio, fim)
1 if inicio < fim
2
umTero = (fim inicio + 1) / 3 // teto, para evitar 0
3
Mergesort-3-Partes(A, inicio, inicio + umTero - 1)
4
Mergesort-3-Partes(A, inicio + umTerco, inicio + 2*umTero - 1)
5
Mergesort-3-Partes(A, inicio + 2*umTero, fim)
6
Intercala(A, inicio, inicio + umTerco - 1, inicio + 2*umTero - 1, fim)

d) (0,3 ponto)
Escreva a equao de recorrncia para Mergesort-3-Partes (no se preocupe com o piso e/ou teto da
diviso).
T(n) = (1) se n =1
T(n) = 3*T(n/3) + (n)

e) (0,7 ponto)
Calcule a complexidade de Mergesort-3-Partes, considerando um vetor com tamanho que potncia de 3.
Apresente a rvore de recurso e a altura da rvore.
c*n
c*(n/3)

c*(n/3)

c*(n/3)

c*(n/9)

c*(n/9)

c*(n/9)

c*(n/9)

c*(n/9)

c*(n/9)

c*(n/9)

c*(n/9)

c*(n/9)

...

...

...

...

...

...

...

...

...

h = log3n
Complexidade = c*n*(log3n + 1) = (n*lgn)

PCS - 3110 Algoritmos e Estrutura de Dados para a Engenharia Eltrica

Questo 2 (2,2 pontos): Gabarito
O Banco X possui dois tipos de atendimento: normal ou preferencial. O preferencial deve ser o prximo a
ser atendido, exceto se houver outro atendimento preferencial em sua frente. Foi utilizada uma nica fila de
prioridade implementada como minHeap para controlar o atendimento nesse cenrio. O programa
composto por um conjunto de funes que controlam a fila. O elemento cliente possui dois atributos: chave
(um nmero que o identifica) e atendimento (com um entre 2 valores: N (normal) ou P (preferencial)).
A funo insere(F, cliente) adiciona um cliente lista de prioridade, considerando se ele normal ou
preferencial. Por exemplo, para os clientes que chegaram na seguinte ordem (N,1), (N,2), (N,3) e (P,4) a
fila ficaria: [(P,4),(N,1),(N,3),(N,2)]. Ao adicionar um cliente preferencial, o resultado deve ser:
[(P,4),(P,5),(N,3),(N,2),(N,1)]. A funo proximo(F) retorna o prximo cliente a ser atendido,
removendo-o da fila.
a) (0,2 pontos) Aps a seguinte ordem de chegada de clientes: (N,1), (N,2), (N,3) , (P,4), (P,5), (N,6), (P,7),
(P,8), (P,9), (N,10), indicar como dever estar a fila de prioridades:
[(P,4), (P,5), (P,7), (P,8), (N,1), (N,6), (N,3), (N,2), (P,9), (N,10)]

b) (0,9 pontos) Complete o algoritmo insere(F, cliente) que permite inserir um cliente na fila de
prioridade, considerando a sua prioridade e a prxima chave (que uma varivel global). No crie uma outra
contagem de prxima chave.
Considere que j existe as funes pai(i), filhoEsquerdo(i), filhoDireito(i).
insere(F, cliente)// insere o elemento cliente, com atributos chave(gerado
// pela funo)e atendimento(N ou P)
1
2

if F.heap-size == F.tamanho
erro overflow

F.heap-size = F.heap-size + 1

F[F.heap-size] = cliente

cliente.chave = proximaChave

proximaChave = proximaChave + 1

i = F.heap-size

while i > 1 and (F[pai(i)].atendimento != P and F[i].atendimento == P)

temp = F[pai(i)]

10

F[pai(i)] = F[i]

11

F[i] = temp

12

i = pai(i)

PCS - 3110 Algoritmos e Estrutura de Dados para a Engenharia Eltrica

c) (0,3 pontos) Considere funo prximo(F), que obtm o prximo cliente da fila de prioridade, e o
algoritmo corrigeMinHeap(F, i), que corrige a fila de prioridade (a ser completado no item d). Para a
seguinte fila de prioridades F, indique o prximo cliente a ser atendido e a nova situao de F, aps a
execuo de prximo(F): [(P,1),(P,5),(P,6),(N,4),(N,2),(N,3),(P,7)]
Valor retornado por prximo(F): (P,1)
Nova situao da fila F: [P5, P7, P6, N4, N2, N3]
d) (0,8 pontos) Considerando a implementao da funo prximo(F), que obtm o prximo cliente da fila
de prioridade, complete o algoritmo corrigeMinHeap(F, i) que corrige a fila de prioridade.
proximo(F)
1
2

// devolve o prximo cliente a ser atendido

if F.heap-size < 1

// testa se fila est vazia

erro underflow

proximoCliente = F[1]

// pega o prximo cliente da fila

F[1] = F[F.heap-size]

// troca primeiro com ltimo da fila

F.heap-size = F. heap-size 1

// atualiza tamanho da fila

corrigeMinHeap(F, 1)

// faz a correo do MinHeap

return proximoCliente

corrigeMinHeap(F, i)

// corrige a posio i do min-Heap F

esquerdo = filhoEsquerdo(i)

direito = filhoDireito(i)

menor = i

if esquerdo <= F.heap-size and (F[i].atendimento != P and

F[esquerdo].atendimento == P) or

(F[i].atendimento == F[esquerdo].atendimento and

7
8
9

F[i].chave > F[esquerdo].chave)

menor = esquerdo
if direito <= F.heap-size and (F[menor].atendimento!= P and

10

F[direito].atendimento == P) or

11

F[i].atendimento == F[direito].atendimento and

12

F[menor].chave > F[direito].chave)

13

menor = direito

14 if menor != i
15

temp = F[i]

16

F[i] = F[menor]

17

F[menor] = F[i]

18

corrigeMinHeap(menor)

PCS - 3110 Algoritmos e Estrutura de Dados para a Engenharia Eltrica

Testes (valor: 4,8 pontos): Gabarito
(A ordem dos testes e das alternativas podem ser diferentes dependendo da prova)

(ANULADA) T1. Assinale a alternativa que indica como devem ser as condies nas linhas 2 e 6 para
que a verso do algoritmo SelectionSort ordene em ordem crescente uma lista duplamente ligada.
Selection-Sort-Linked-List(L)
1 novoInicio = NIL
2 while ___________________
3
x = L.inicio
4
atual = L.inicio.proximo
5
while atual NIL
6
if ___________________
7
x = atual
8
atual = atual.proximo;
9
10
11
12
13
14

// Removendo o x de L
if x.anterior NIL
x.anterior.proximo = x.proximo
else L.inicio = x.proximo
if x.proximo NIL
x.proximo.anterior = x.anterior

15
// Inserindo o x na nova lista
16
x.proximo = novoInicio
17
if novoInicio NIL
18
novoInicio.anterior = x
19
novoInicio = x
20
x.anterior = NIL
21 L.inicio = novoInicio
a)
b)
c)
d)
e)

Linha
Linha
Linha
Linha
Linha

2:
2:
2:
2:
2:

L.inicio.proximo
L.inicio.proximo
L.inicio NIL ;
L.inicio NIL ;
L.inicio.proximo

NIL
NIL
Linha
Linha
NIL

; Linha 6:
; Linha 6:
6: x.chave
6: x.chave
; Linha 6:

x.chave < atual.chave

x.chave > atual.chave
< atual.chave
> atual.chave
x.chave atual.chave

Alternativa c
T2 Assinale a alternativa incorreta sobre o algoritmo Quicksort:
a) A complexidade (n2) no pior caso e (n*lgn) no melhor caso.
b) Um pior caso do algoritmo acontece quando o vetor de entrada est em ordem crescente e o ltimo
elemento for escolhido como piv.
c) O melhor caso do algoritmo acontece quando o piv divide o vetor em duas partes de mesmo tamanho.
d) Uma forma de diminuir a chance de ocorrncia do pior caso usar o algoritmo de insero para vetores
pequenos.
e) As chamadas recursivas ao algoritmo acontecem aps se particionar o vetor.

PCS - 3110 Algoritmos e Estrutura de Dados para a Engenharia Eltrica

Alternativa d

T3. Um aluno escreveu a seguinte verso do algoritmo de ordenao por insero. O que ela faz?
Insertion-Sort(A)
1 for j = A.tamanho - 1 downto 1
2
chave = A[j]
i = j + 1
3
4
while i <= A.tamanho and A[i] < chave
5
A[i - 1] = A[i] //shift de A[i]
i = i + 1
6
7
A[i - 1] = chave
a) Ordena em ordem decrescente.
b) Ordena em ordem crescente.
c) Coloca o mesmo valor em todo o vetor.
d) Mantm o vetor na mesma ordem original.
e) Fica em loop infinito.

Alternativa b
T4. Quais dos seguintes arranjos so Max-Heaps?
I. [17, 6, 9, 5, 4, 7, 6, 4, 5]
a) I e II, apenas.

II. [8, 3, 7, 2, 1, 6, 6, 1]

b) II e III, apenas.

III. [10, 8, 9, 4, 5, 6, 7, 0, 1, 2, 3]

c) I e III, apenas.

d) I, II e III.

e) Nenhum deles.

Alternativa d
T5. Analise o algoritmo a seguir e assinale a alternativa correta. Para a anlise, considere que n seja
potncia de 2.
j = n
while j <= (n*n)
for i = 1 to n
Imprime (passei aqui)
j = j*2
O algoritmo :
a) (n2)

b) (n)

Alternativa c

c) (n * lg(n))

1
lg(n) +
(n + 1)
n*(lg n
lg(n) +

d) (n2 * lg(n))

1 + 1
* (lg(n) + 1)
+ 1)
1

e) nenhuma das demais alternativas

PCS - 3110 Algoritmos e Estrutura de Dados para a Engenharia Eltrica

T6. Considerando-se a complexidade dos algoritmos de ordenao para a escolha do algoritmo mais
adequado a determinada aplicao, assinale a alternativa correta.
a) Numa aplicao em que os dados encontram-se praticamente ordenados, com um nmero muito
pequeno de elementos fora de ordem em relao ao total, o melhor algoritmo seria o Selection Sort.
b) O Mergesort melhor que o Quicksort somente para uma entrada de tamanho muito grande.
c) Mesmo numa aplicao em que o volume de dados pequeno, como por exemplo a ordenao dos
alunos de uma disciplina de graduao da Poli, importante analisar a complexidade assinttica do
algoritmo.
d) Uma forma de se decidir pelo melhor algoritmo para dada aplicao test-los com uma quantidade
de amostras pequenas dos dados, desde que essas amostras representem, estatisticamente, como so
os nveis tpicos de embaralhamento dos dados para essa aplicao.
e) Nenhuma das demais alternativas correta.
Alternativa e.
a) Nesse caso o Insertion Sort seria mais adequado que o Selection Sort porque no melhor caso seu
crescimento linear, enquanto que o segundo tem crescimento quadrtico mesmo no melhor caso.
b) possvel o Mergesort ser melhor que o Quicksort para entradas pequenas e ser pior para entradas
grandes.
c) No faz sentido avaliar a complexidade do algoritmo para pequenos volumes de dados
d) No possvel decidir pelo melhor algoritmo com testes envolvendo pequenos volumes de dados, pois a
partir de determinados volumes que a forma da curva de crescimento se torna crtica

T7. Considere uma tabela hash de tamanho 7, inicialmente vazia, e uma funo de hash h(x) = x mod 7.
Assinale a alternativa que mostra corretamente o contedo resultante da tabela aps a insero dos valores
{17, 27, 39, 31, 22, 12, 14} na ordem dada, considerando as seguintes estratgias de tratamento de colises:
endereamento aberto com sondagem linear (open addressing with linear probing) e por encadeamento
(separate chaining). A resposta dada como <ndice do vetor> [contedo associado a este ndice]:
a)

0 [12] 1 [22] 2 [14] 3 [17] 4 [39] 5 [31] 6 [27] ;

0 [14] 1 [22] 2 [ ] 3 [17, 31] 4 [39] 5 [12] 6 [27]

b)

0 [17] 1 [27] 2 [39] 3 [31] 4 [22] 5 [12] 6 [14] ;

0 [17] 1 [27] 2 [39] 3 [31] 4 [22] 5 [12] 6 [14]

c)

0 [12] 1 [22] 2 [17] 3 [39] 4 [14] 5 [27] 6 [31] ;

0 [12] 1 [22] 2 [14] 3 [17] 4 [39] 5 [31] 6 [27]

d)

0 [14] 1 [22] 2 [ ] 3 [17, 14] 4 [39] 5 [31] 6 [27] ;

0 [12] 1 [22] 2 [14] 3 [17] 4 [39] 5 [31] 6 [27]

e)

0 [12] 1 [22] 2 [14] 3 [17] 4 [39] 5 [31] 6 [27] ;

0 [14] 1 [22] 2 [17] 3 [31] 4 [39] 5 [12] 6 [27]

Alternativa a.

PCS - 3110 Algoritmos e Estrutura de Dados para a Engenharia Eltrica

T8. Considere o algoritmo Quicksort e Particionar dados a seguir. Considere o seguinte vetor de entrada
com 10 elementos: A = [40 48 62 28 31 9 74 88 52 41]. Assinale a alternativa que indica corretamente
os parmetros de entrada na segunda vez que Particionar(A, inicio, fim) chamada (isto , na segunda vez
que o passo 2 do Quicksort atingido, antes de sua execuo).
Quicksort(A, incio, fim)
1. if incio < fim
2. piv = Particionar(A, incio, fim)
3. Quicksort(A, incio, piv 1)
4. Quicksort(A, piv + 1, fim)

Particionar(A, incio, fim)

1. piv = A[fim]
2. i = incio 1
3. for j = incio to fim - 1
4.
if A[j] piv
5.
i=i+1

// troca A[i] com A[j]

// troca A[i + 1] com A[fim]
12. return i + 1

a)

Particionar([9 28 31 40 41 48 74 88 52 62], 1, 10).

b)

Particionar([40 28 31 9 41 48 74 88 52 62], 1, 4).

c)

Particionar([9 28 31 40 41 48 74 88 52 62], 1, 5).

d)

Particionar([40 28 31 9 41 48 74 88 52 62], 1, 10).

e)

Nenhuma das outras alternativas correta.

Alternativa b.