Aluno: Vinicius Mendonça Borges Celeri Matrícula: 22102531

Correção da Prova 1 – Fundamentos da Estrutura da Informação

QUESTÃO 1

Passagem #1

Passo 1 : 1 comparação  Passo 2 : 1 troca  Passo 3: 1 comparação  Passo 4: 1 comparação

Passo 5 : 1 troca  Passo 6: 1 comparação

Passagem #2

Passo 7: 1 comparação  Passo 8: 1 comparação Passo 9: 1 troca  Passo 10: 1 comparação

Passagem #3

Passo 11: 1 comparação  Passo 12 : 1 troca  Passo 13: 1 comparação  Passo 14: 1 troca

Passagem #4

Passo 15: 1 comparação  Passo 16: 1 troca  Array ordenado

Analisando as passagens descrita no enunciado, há um total de 16 passos, sendo esses 10 comparações

e 6 trocas. Ainda nesse caso do enunciado, todas as comparações possíveis são executadas, o que, de certo
modo, pode indicar que o algoritmo em questão não possui um dispositivo de pausa antecipada e, portanto,
𝑵𝟐 −𝑵
sempre realiza todas as comparações possíveis, que equivalem a comparações. O número de trocas,
𝟐

nesse caso, não possui um padrão por não se tratar nem de um pior nem de um melhor caso, mas
Assim, se não há um mecanismo de pausa antecipada e o algoritmo faz, sempre, todas as comparações
𝑵𝟐 −𝑵
possíveis (indicado pela função acima), o melhor caso desse algoritmo (com o array já ordenado) fará 𝟐

comparações e 0 trocas (pois já está tudo no lugar), se caracterizando por O(N²).

 𝑵𝟐 −𝑵
No pior caso (ou seja, com o Array com a ordem invertida), o algoritmo ainda realizaria as 𝟐
𝑵𝟐−𝑵
comparações mínimas. Somado a isso, o algoritmo também realizará trocas (ou seja, para cada
𝟐

comparação, há uma troca). Assim, o total de passos será a soma do número de comparações e do número de
𝑵𝟐−𝑵 𝑵𝟐−𝑵
trocas, ou seja, + = N² - N passos. Logo, no pior caso do algoritmo ainda terá uma complexidade
𝟐 𝟐

no tempo de O(N²).
Como dito antes, o caso médio pode ser caracterizado por um caso aleatório que não se encaixa nem
como melhor ou pior caso. Assim, será considerado “caso médio” o caso apresentado no enunciado,
possuindo, então, uma complexidade no tempo de O(N²).

CONCLUSÃO:

◘ Melhor caso (array ordenado) : O(N²)

◘ Pior caso (Array invertido) : O(N²)
◘ Caso médio (enunciado): O(N²)

QUESTÃO 2

Falsa! Um cálculo do fator de carga de uma tabela Hash é, de fato, importante para evitar que hajam
colisões e, consequentemente, um mau desempenho na execução de tarefas que usam de uma tabela hash.
Porém, o enunciado afirma que esse cálculo é importante “independente da função hash utilizada”, o
que faz com que a afirmação fique, como um todo incorreta, já que um cálculo do fator de carga não é relevante
se a função a ser usada não exigir isso. Logo,
Um exemplo seria uma função que analise o comprimento das strings ( usando a função “len”, no caso
do Python) e, ilustrando, insere as strings com um comprimento par na célula 1, enquanto insere as strings de
comprimento ímpar na célula 2. Nesse caso, a função hash seria pouquíssimo eficiente (pois geraria muitas
colisões), mas, independentemente, não necessitaria de um cálculo do fator de carga, visto que todos as chaves
seriam inseridas apenas nesses dois espaços da memória.

QUESTÃO 3

Alternativa A) A função printa um ‘*’ uma certa quantidade de vezes, quantidade essa que varia de acordo
com dois laços do tipo ’for’ acoplados. O primeiro loop realizará uma função N vezes, enquanto o segundo
(que está encadeado com o primeiro) realizará um print N² vezes. Dessa forma, a quantidade de vezes em que
um * será printado será de N x N² vezes, ou seja, N³ vezes.
Logo, a complexidade no tempo dessa função é O(N³), ou seja, um crescimento polinomial cúbico.

Alternativa B) Nessa função, há dois laços do ‘for’, porém, desta vez, estão em sequência (o que indica uma
soma da quantidade de passos realizadas por cada um). Assim, o primeiro loop realizará o print do ‘*’ N vezes,
enquanto o segundo, de forma independente ao primeiro, realizará o print N² vezes.
Assim, será realizados N + N² prints, indicando uma complexidade no tempo O(N² + N) que, simplificando
os termos de menor grau, será reduzida a O(N²).

QUESTÃO 4

Alternativa A) Atende! Por mais que essa função seja um péssimo caso de função hash (pois qualquer chave
será inserida numa mesma célula, o que sempre gerará colisões e prejudicará o desempenho de eficiência do
algoritmo), ela cumpre os requisitos para uma tabela Hash, já que cada valor inserido poderá ser localizado e
retornará apenas um único par chave-valor.

Alternativa B) Não atende! A cada valor inserido, será retornado uma célula aleatória, o que impossibilitará
(ou dificultará muito) a busca e a utilização da tabela.

Alternativa C) Não atende! será difícil buscar por pares chave-valor já registrados na tabela, já que a função
retorna apenas o valor de células vazias (no caso, a próxima vazia no espaço da memória).

Alternativa D) Atende! Por mais que não seja um caso muito satisfatório (visto que, considerando uma
grande rede de dados, surgirão chaves com um mesmo comprimento e, consequentemente, muitas colisões
em espaços já ocupados), essa função cumpre os requisitos para ser considerada uma função hash.

QUESTÃO 5

Nessa função, há 1 laço “maior” (um while) que abriga dois laços “for” independentes entre si.
Nesse caso, não pode ser tratar de uma complexidade do tipo O(Logn), visto que todo o array é
“tocado”, pois cada laço for realizará as operações de comparação e troca num intervalo específico do array
(o primeiro, começará no índice 1 e vai pulando alternadamente; enquanto o segundo, além de também pular
alternadamente, começará com o elemento de índice 0). Assim, o array sendo trabalhado nunca ficará menor
a cada passagem, descaracterizando o algoritmo como uma complexidade logarítmica no tempo.
Analisando, pode-se concluir que cada “passagem” representa uma repetição do laço maior (while),
enquanto os loops for dentro farão suas operações independente do maior (no caso, em algumas situações,
apenas um dos loops fará trocas, pois o outro não terá condições atendidas e realizará apenas comparações).
Assim, considerando alguns valores, (no caso 5 e 7) e que todas as comparações sejam executadas(pois os
laços for não possuem condicionais que produzam uma pausa antecipada), o total de passos, considerando o
pior caso (array invertido) será N² - N passos (pra N = 5, 20 passos; para N = 7, 42 passos), indicando que o
algoritmo possuirá uma complexidade no tempo de comportamento quadrático.
Conclusão: o algoritmo possui complexidade O(N²).