Pular para o conteúdo principal

Questão de Programação — Conceitos básicos de programação — Quadrix 2025

ProgramaçãoConceitos básicos de programação
Código
qg603668
Banca
Quadrix
Órgão
SEDF
Ano
2025
Nível
Superior
Cargo
Professor de Educação Básica: Informática
Quanto aos algoritmos, à programação orientada a objetos e à arquitetura MVC, julgue o item seguinte.A complexidade de tempo do algoritmo de ordenação Merge Sort no pior caso é O(n log n), o que o torna mais eficiente que algoritmos como o Bubble Sort.
  1. CCerto
  2. EErrado
Revelar gabarito e comentário

GabaritoC — Certo

Comentário gerado por IA. É um apoio ao estudo, ancorado em fontes, mas pode conter imprecisões — confira sempre na fonte oficial (lei, súmula, edital e gabarito da banca). Encontrou um erro? Use “Reportar”.

Complexidade de algoritmos de ordenação: Merge Sort × Bubble Sort

Gabarito: C — CERTO. A afirmação está correta porque o Merge Sort, no pior caso, apresenta complexidade de tempo O(n log n), enquanto o Bubble Sort apresenta O(n²) — e, para entradas grandes, O(n log n) é assintoticamente mais eficiente que O(n²). Essa é uma relação clássica de análise de algoritmos, cobrada em conceitos básicos de programação e estruturas de dados.

A complexidade de tempo de um algoritmo descreve como o número de operações cresce conforme o tamanho da entrada (n) aumenta. Não se trata de medir segundos, mas da taxa de crescimento — a chamada notação Big-O. Ela ignora constantes e termos de menor ordem, focando no comportamento dominante quando n tende ao infinito. Por isso, comparar O(n log n) com O(n²) é comparar duas curvas de crescimento: a primeira cresce de forma quase linear, a segunda cresce de forma quadrática, tornando-se inviável para entradas grandes.

O Merge Sort é um algoritmo de ordenação baseado na técnica de divisão e conquista: divide o vetor ao meio recursivamente até restarem subvetores de tamanho 1 e, depois, intercala (merge) as partes ordenadas. Cada nível de divisão custa O(n) para intercalar, e há log n níveis — daí o O(n log n) em todos os casos (melhor, médio e pior). Já o Bubble Sort percorre o vetor repetidamente, comparando e trocando elementos adjacentes; no pior caso (vetor invertido), ele faz n passagens com n comparações cada, resultando em O(n²).

Na prática, a diferença é brutal. Para um vetor de 1 milhão de elementos, o Merge Sort executa cerca de 20 milhões de operações (n log n ≈ 10⁶ × 20), enquanto o Bubble Sort executa cerca de 500 bilhões (n² ≈ 10¹²) — uma diferença de 25 mil vezes. É por isso que algoritmos quadráticos funcionam bem em testes pequenos, mas se tornam inviáveis em produção com grandes volumes de dados.

A pegadinha que a banca poderia explorar é inverter os valores ou afirmar que o Merge Sort é O(n²) no pior caso — o que é falso, pois o Merge Sort mantém O(n log n) mesmo no pior cenário. Outra confusão comum é trocar a complexidade do Merge Sort pela do Quick Sort (que tem pior caso O(n²), embora o caso médio seja O(n log n)). Aqui, a afirmação está tecnicamente precisa e correta.

Guarde a fronteira entre as complexidades: O(n log n) é a classe dos algoritmos eficientes (Merge Sort, Heap Sort), enquanto O(n²) é a classe dos algoritmos simples e lentos (Bubble Sort, Insertion Sort, Selection Sort). É exatamente nessa distinção que a questão se apoia.

Alternativa C — ✅ CERTOGABARITO

A afirmação está correta. O Merge Sort tem complexidade de tempo O(n log n) no pior caso, pois divide o problema em duas metades (log n níveis) e gasta O(n) para intercalar cada nível. O Bubble Sort, por sua vez, tem complexidade O(n²) no pior caso, pois realiza n passagens com n comparações cada. Como O(n log n) cresce muito mais lentamente que O(n²) para n grande, o Merge Sort é, de fato, mais eficiente que o Bubble Sort. A comparação está tecnicamente precisa e reflete o conhecimento clássico de análise de algoritmos.

Alternativa E — ❌ ERRADO

A afirmação não é falsa. Se a banca considerasse esta alternativa como correta, estaria negando uma relação matemática bem estabelecida: O(n log n) < O(n²) para n suficientemente grande. O erro aqui seria do candidato que confundisse a complexidade do Merge Sort com a do Quick Sort (que tem pior caso O(n²)) ou que acreditasse que o Merge Sort é O(n²) no pior caso — o que não ocorre, pois o Merge Sort mantém O(n log n) em todos os cenários. Portanto, esta alternativa está incorreta.

NÃO CAIA NESSA!

Para fixar, memorize a tabela das complexidades dos algoritmos de ordenação mais cobrados:

Algoritmo

Melhor caso

Caso médio

Pior caso

Bubble Sort

O(n)

O(n²)

O(n²)

Insertion Sort

O(n)

O(n²)

O(n²)

Selection Sort

O(n²)

O(n²)

O(n²)

Merge Sort

O(n log n)

O(n log n)

O(n log n)

Quick Sort

O(n log n)

O(n log n)

O(n²)

Heap Sort

O(n log n)

O(n log n)

O(n log n)

A pegadinha clássica é trocar o pior caso do Quick Sort (O(n²)) pelo do Merge Sort. Com essa tabela, você elimina a dúvida na hora da prova.

Gabarito: letra C — a afirmação está CERTA.

Link permanente: /questoes/qg603668