📚 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.02 · Listas Enlazadas

16 preguntas con respuesta en este tema.

🎯 Autoevaluación (3)

1
🎯 AE

¿Qué es una lista enlazada?

  • A. Un arreglo dinámico
  • B. Una estructura de nodos conectados por punteros, cada uno con dato y enlace al siguiente ✓ CORRECTA
  • C. Un archivo
  • D. Una función
💡 Por qué es correcta:

Lista enlazada: colección de nodos. Cada nodo tiene dato y puntero al siguiente. Inserción/eliminación O(1) si tienes el puntero.

2
🎯 AE

¿Cuál es la ventaja principal de una lista enlazada sobre un arreglo?

  • A. Acceso más rápido por índice
  • B. Inserción y eliminación en cualquier posición en O(1) ✓ CORRECTA
  • C. Usa menos memoria
  • D. Es más rápida para todo
💡 Por qué es correcta:

Lista: insertar/eliminar es O(1) si tienes el puntero al nodo. Arreglo: O(n) por desplazamiento.

3
🎯 AE

¿Cómo se detecta el final de una lista enlazada simple?

  • A. El último nodo tiene NULL en su puntero al siguiente ✓ CORRECTA
  • B. Hay un campo "último"
  • C. Por el tamaño
  • D. Por un marcador especial
💡 Por qué es correcta:

El último nodo tiene su puntero `next` apuntando a nullptr (o NULL), indicando fin de la lista.

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

1
📝 MC

¿Qué es una lista enlazada?

  • A. Array dinámico
  • B. Estructura de nodos conectados por punteros ✓ CORRECTA
  • C. Archivo
  • D. Función
💡 Por qué es correcta:

Lista: nodos con dato y puntero al siguiente. Tamaño dinámico.

2
📝 MC

¿Cuál es la ventaja de una lista sobre un array?

  • A. Acceso por índice
  • B. Inserción/eliminación en O(1) si tienes el puntero ✓ CORRECTA
  • C. Menos memoria
  • D. Más rápido para todo
💡 Por qué es correcta:

Lista: insertar/eliminar es O(1) con el puntero al nodo. Array: O(n) por desplazamiento.

3
📝 MC

¿Cómo se detecta el final de una lista simplemente enlazada?

  • A. Por un campo "último"
  • B. El último nodo tiene nullptr en su puntero al siguiente ✓ CORRECTA
  • C. Por el tamaño
  • D. Por un marker
💡 Por qué es correcta:

Último nodo: ptr->next == nullptr.

4
📝 MC

¿Qué es un nodo en una lista enlazada?

  • A. Una función
  • B. Estructura con dato y puntero al siguiente ✓ CORRECTA
  • C. Un array
  • D. Un archivo
💡 Por qué es correcta:

struct Nodo { T dato; Nodo* siguiente; }.

5
📝 MC

¿Cómo se inserta un nodo al inicio de una lista?

  • A. Con un for
  • B. nuevo->siguiente = cabeza; cabeza = nuevo; ✓ CORRECTA
  • C. Solo al final
  • D. No se puede
💡 Por qué es correcta:

Insertar al inicio: O(1). nuevo apunta a la cabeza actual, cabeza = nuevo.

6
📝 MC

¿Cómo se elimina el primer nodo?

  • A. free(cabeza)
  • B. tmp = cabeza; cabeza = cabeza->siguiente; delete tmp; ✓ CORRECTA
  • C. Solo con un for
  • D. No se puede
💡 Por qué es correcta:

Guardar referencia, avanzar cabeza, liberar el viejo. O(1).

7
📝 MC

¿Lista doblemente enlazada tiene:

  • A. Solo un puntero
  • B. Puntero al siguiente y al anterior ✓ CORRECTA
  • C. Solo 2 nodos
  • D. Un array
💡 Por qué es correcta:

Doble: prev y next. Permite recorrer hacia atrás. Más memoria.

8
📝 MC

¿Lista circular termina en?

  • A. nullptr
  • B. El primer nodo (cabeza) ✓ CORRECTA
  • C. Un valor null
  • D. El último nodo
💡 Por qué es correcta:

Circular: el último nodo apunta a la cabeza. No hay null al final.

9
📝 MC

¿Complejidad de buscar en lista enlazada?

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

Lista: no hay acceso por índice, hay que recorrer n nodos en el peor caso. O(n).

10
📝 MC

¿Cuándo es mejor usar lista que vector?

  • A. Siempre
  • B. Cuando hay muchas inserciones/eliminaciones en medio ✓ CORRECTA
  • C. Solo para pocos datos
  • D. Nunca
💡 Por qué es correcta:

Lista: O(1) insertar/eliminar. Vector: O(n) por desplazamiento.

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

11
✍️ AB

Diseña una lista enlazada con insertar al inicio, eliminar por valor, y mostrar. Código en pseudocódigo.

💡 Por qué es correcta:

struct Nodo { T dato; Nodo* sig; }; Nodo* cabeza = nullptr; void insertar(T v) { Nodo* n = new Nodo{v, cabeza}; cabeza = n; } void eliminar(T v) { if (cabeza && cabeza->dato==v) { Nodo* t = cabeza; cabeza = cabeza->sig; delete t; return; } for (Nodo* p=cabeza; p->sig; p=p->sig) if (p->sig->dato==v) { Nodo* t = p->sig; p->sig = t->sig; delete t; return; } }.

12
✍️ AB

¿Cuál es la diferencia entre lista simplemente y doblemente enlazada? ¿Cuándo usar cada una?

💡 Por qué es correcta:

Simple: cada nodo tiene dato y puntero al siguiente. Doble: también al anterior. Simple: menos memoria (1 puntero). Doble: permite recorrido inverso, eliminación más fácil. Usar doble cuando necesitas navegar hacia atrás o eliminar un nodo dado.

13
✍️ AB

¿Cómo detectarías un ciclo en una lista enlazada? Da el algoritmo.

💡 Por qué es correcta:

Algoritmo de la liebre y la tortuga (Floyd): tortuga avanza 1 paso, liebre avanza 2. Si se encuentran, hay ciclo. Si la liebre llega a null, no hay ciclo. O(n) tiempo, O(1) espacio.

📝 ¿Listo para evaluarte?

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