📚 DE LIBRE ACCESO · SIN LOGIN

Respuestas modelo

Consulta aquí las respuestas correctas y explicaciones de las autoevaluaciones y los tests del manual. Ideal para repasar antes de un test o aclarar dudas.

111
🎯 autoevaluación
355
📝 test · opción múltiple
111 / 111
✍️ test · abiertas con respuesta
37
temas cubiertos
✕ Limpiar

4.07 · Divide y Vencerás: Quicksort y Mergesort

16 preguntas con respuesta en este tema.

🎯 Autoevaluación (3)

1
🎯 AE

¿Qué algoritmo de ordenamiento usa la estrategia "divide y vencerás"?

  • A. Burbuja
  • B. Mergesort y Quicksort ✓ CORRECTA
  • C. Inserción
  • D. Selección
💡 Por qué es correcta:

Mergesort y Quicksort dividen el arreglo, ordenan cada mitad recursivamente, y combinan. O(n log n) en promedio.

2
🎯 AE

¿Cuál es la complejidad en el PEOR caso de Quicksort?

  • A. O(n)
  • B. O(log n)
  • C. O(n log n)
  • D. O(n²) ✓ CORRECTA
💡 Por qué es correcta:

Quicksort es O(n log n) en promedio pero O(n²) en el peor caso (cuando el pivote es siempre el menor o mayor). Se mitiga con pivote aleatorio.

3
🎯 AE

¿Cómo funciona Mergesort?

  • A. Compara adyacentes
  • B. Divide el arreglo, ordena cada mitad, y fusiona (merge) los resultados ✓ CORRECTA
  • C. Selecciona el menor
  • D. Inserta en posición
💡 Por qué es correcta:

Mergesort: divide recursivamente hasta arreglos de 1 elemento, luego fusiona ordenadamente. Garantiza O(n log n).

📝 Test · Sección A · Opción múltiple (10)

1
📝 MC

¿Qué es "divide y vencerás"?

  • A. Bucle simple
  • B. Estrategia: dividir el problema en subproblemas, resolver, combinar ✓ CORRECTA
  • C. Hash
  • D. Recursión infinita
💡 Por qué es correcta:

Divide y vencerás: divide, resuelve recursivamente, combina. MergeSort, QuickSort.

2
📝 MC

¿Cuál es la complejidad típica de divide y vencerás?

  • A. O(n)
  • B. O(n log n) si la división y combinación son O(n) o menor ✓ CORRECTA
  • C. O(n²)
  • D. O(2^n)
💡 Por qué es correcta:

T(n) = 2T(n/2) + O(n) → O(n log n) por Master Theorem.

3
📝 MC

¿Cómo funciona Mergesort?

  • A. Compara adyacentes
  • B. Divide, ordena cada mitad, fusiona ordenadamente ✓ CORRECTA
  • C. Selecciona
  • D. Hash
💡 Por qué es correcta:

Mergesort: divide en 2, ordena cada mitad recursivamente, fusiona (merge) en O(n).

4
📝 MC

¿Mergesort es estable?

  • A. No
  • B. Sí ✓ CORRECTA
  • C. Solo con comparador
  • D. Solo en C++
💡 Por qué es correcta:

Mergesort: estable. Mantiene el orden relativo de elementos iguales.

5
📝 MC

¿Cómo funciona Quicksort?

  • A. Compara adyacentes
  • B. Selecciona pivote, particiona, ordena recursivamente ✓ CORRECTA
  • C. Hash
  • D. Inserta
💡 Por qué es correcta:

Quicksort: pivote, partición (< pivote | pivote | > pivote), recursión.

6
📝 MC

Peor caso de Quicksort:

  • A. O(n)
  • B. O(n²) cuando el pivote es siempre el peor ✓ CORRECTA
  • C. O(log n)
  • D. O(n log n) siempre
💡 Por qué es correcta:

Peor caso: pivote siempre el menor o mayor (array ordenado + pivote fijo).

7
📝 MC

¿Cómo mejorar el peor caso de Quicksort?

  • A. Más memoria
  • B. Pivote aleatorio o mediana de tres ✓ CORRECTA
  • C. Más comparaciones
  • D. Compilar
💡 Por qué es correcta:

Pivote aleatorio o mediana de 3: en la práctica, evita el peor caso.

8
📝 MC

Quicksort vs Mergesort en uso de memoria:

  • A. Igual
  • B. Quicksort: O(log n) de stack, Mergesort: O(n) de array extra ✓ CORRECTA
  • C. Mergesort usa menos
  • D. Ambos O(1)
💡 Por qué es correcta:

Quicksort: in-place, O(log n) de stack. Mergesort: O(n) de array auxiliar.

9
📝 MC

Mergesort es preferible cuando:

  • A. Memoria es crítica
  • B. Se necesita estabilidad o datos muy grandes ✓ CORRECTA
  • C. Velocidad pura
  • D. Solo con arrays pequeños
💡 Por qué es correcta:

Mergesort: estable, predecible O(n log n). Útil cuando se requiere estabilidad.

10
📝 MC

Quicksort es típicamente el más rápido en:

  • A. Todos los casos
  • B. Promedio para datos aleatorios ✓ CORRECTA
  • C. Datos ordenados
  • D. Solo con strings
💡 Por qué es correcta:

Quicksort: en promedio O(n log n) con muy bajo constante. Rápido en práctica para datos aleatorios.

✍️ Test · Sección B · Preguntas abiertas (3)

11
✍️ AB

Diseña un Mergesort. ¿Es estable? ¿Por qué?

💡 Por qué es correcta:

Mergesort(array, izq, der) { if (izq < der) { mid = (izq+der)/2; Mergesort(izq, mid); Mergesort(mid+1, der); merge(izq, mid, der); } }. La función merge mantiene el orden: si izq[i] <= der[j], tomar izq[i]. Es estable porque la condición es <=, no <.

12
✍️ AB

¿Por qué Quicksort suele ser más rápido en la práctica que Mergesort a pesar de tener la misma complejidad?

💡 Por qué es correcta:

Quicksort: in-place, mejor locality of reference (accede a memoria cercana), bajo constante. Mergesort: O(n) de memoria extra para el array auxiliar, peor cache behavior. Para datos en memoria, Quicksort gana en práctica.

13
✍️ AB

¿Cómo elegirías el pivote en Quicksort? Compara 3 estrategias.

💡 Por qué es correcta:

Primer elemento: simple pero falla con datos ordenados. Aleatorio: robusto contra patrones, fácil. Mediana de tres: robusto y rápido (usa el medio de primero, medio, último). Mediana de tres es la mejor en la práctica.

📝 ¿Listo para evaluarte?

Regístrate o inicia sesión para tomar la autoevaluación o el test de este tema y registrar tu puntaje.