Skip to content

Tutoría 3: Estructuras de Datos Lineales (Pilas y Colas) y Estrategia de Examen

1. Resumen Ejecutivo

Esta sesión se centró en la corrección técnica de la Actividad 1, detallando la implementación manual de Pilas (Stacks) y Colas (Queues) mediante Nodos, sin el uso de librerías auxiliares. Se revisaron los algoritmos paso a paso para los métodos fundamentales (push/insert, pop/remove, search). Finalmente, se ofreció una estrategia crítica para el examen final: gestión del tiempo, configuración del entorno de desarrollo (IDE) y tipología de ejercicios.

2. Conceptos Clave Nodo (Node):* Unidad básica de almacenamiento que contiene el dato (data) y un puntero/referencia al siguiente elemento (next).

  • Pila (Stack): Estructura LIFO (Last In, First Out). El último en entrar es el primero en salir. Se gestiona principalmente con un puntero TOP.
  • Cola (Queue): Estructura FIFO (First In, First Out). El primero en entrar es el primero en salir. Requiere punteros a HEAD (inicio) y TAIL (fin).
  • Linked List (Librería): Su uso está prohibido en esta asignatura para implementar las estructuras; debe hacerse manualmente con nodos.
  • Skeleton Code: Estructura de código parcial que se proporcionará en el examen para ser rellenada.

3. Desarrollo del Temario###3.1. Feedback General y Errores ComunesEl profesor destacó puntos críticos que afectan la calificación y serán vitales en el examen:

  • Prohibición de Librerías: Usar LinkedList en lugar de crear la estructura de nodos manualmente penaliza gravemente (en la actividad se aprobó con un 5.0 por "pena", pero en el examen es suspenso).
  • Uso de IA: Se detecta fácilmente. Usarla en prácticas impide desarrollar la lógica necesaria para el examen, donde no habrá ayuda.
  • Documentación (Memorias): Una buena memoria no es solo texto; debe incluir capturas del código y explicaciones de por qué se elaboró el método de esa forma.
  • Comentarios: El código debe estar comentado para facilitar su reutilización y lectura.

3.2. Implementación de PILA (Stack)Se debe estructurar una clase PILA (o dentro de ella la clase NODO).

Atributos* TOP: Tipo Nodo. Referencia a la cima.

  • SIZE (Opcional): Entero para contar elementos.

Métodos PrincipalesConstructor (Pila Vacía):

Método PUSH (Insertar): Añadir un elemento a la cima.

  1. Crear Nodo: Se instancia el nuevo nodo (queda "flotando en el aire").
  2. Enlazar: El puntero .next del nuevo nodo debe apuntar al antiguo TOP.
  3. Actualizar TOP: El puntero TOP pasa a ser el nuevo nodo.
  4. Actualizar Size: Si usas el atributo, incrementa +1.

Método POP (Eliminar/Sacar): Condición vital: Si TOP == NULL, retornar NULL.

  1. Guardar Dato: Almacenar el valor de TOP en una variable auxiliar para retornarlo al final.

  2. Mover Puntero: TOP se actualiza a TOP.next (el segundo elemento pasa a ser el primero).

    "Al mover el TOP al segundo elemento, el primero se elimina lógicamente (se pierde la referencia)."

  3. Retornar: Devolver el valor guardado.

Método SEARCH (Buscar): Recorrido lineal desde el TOP hacia abajo.

  • ¡OJO AL DATO!: Para comparar valores, **usar .equals()** y no ==.

    Explicación: El operador == en Java cachea valores entre -128 y 127. Fuera de ese rango, puede fallar al comparar objetos enteros. .equals() es seguro.

Método TOSTRING: Formato libre, pero se recomienda imprimir "HEAD" y luego los elementos salto de línea por salto de línea para visualización vertical. Si está vacía, debe imprimir "EMPTY STACK".

3.3. Implementación de COLA (Queue)Requiere dos punteros para eficiencia: HEAD (Cabeza) y TAIL (Cola).

Método INSERT (Enqueue)Añadir elemento al final.

  • Caso 1: Cola Vacía.

  • Tanto HEAD como TAIL apuntan al nuevo nodo.

  • Caso 2: Cola con elementos.

  • TAIL.next apunta al nuevo nodo (enlazamos el último actual con el nuevo).
  • Actualizamos el puntero TAIL para que sea el nuevo nodo.
  • Incrementar SIZE.

Método REMOVE (Dequeue)Sacar elemento del principio (HEAD).

  1. Si está vacía, retornar NULL.
  2. Guardar el valor de HEAD.
  3. HEAD pasa a ser HEAD.next.
  4. ¡OJO AL DATO!: Si tras eliminar, la lista queda vacía (solo había 1 elemento), hay que asegurar que TAIL también se actualice (posiblemente a null, dependiendo de la implementación lógica).

3.4. Estrategia "Elite" para el Examen FinalEl profesor reveló detalles técnicos cruciales sobre la prueba final.

Estructura del Examen

  • Duración: 2 Horas.
  • Formato: 2 Ejercicios de programación (Java).
  • Ejercicio A: Valor 4 puntos (Más corto/sencillo).

  • Ejercicio B: Valor 6 puntos (Más largo/complejo).

  • Entorno: IDE (Eclipse, IntelliJ, etc.) totalmente vacío/limpio.

  • Recomendación: El día anterior, vacía tu IDE. Guarda proyectos antiguos en un USB si quieres, pero llega al examen con el workspace limpio para evitar acusaciones de copia.

Táctica de Resolución>

"Yo si fuera vosotros, empezaría por el de 4 puntos. Os lo quitáis en media hora, os sube la moral y vais más ligeros al de 6 puntos. Si empezáis por el de 6 y os atascáis, podéis perder el tiempo y no hacer ninguno."

Contenido Esperado

  • No se repiten ejercicios idénticos a los de clase, pero sí la estructura.
  • Se proporcionará un esqueleto de código (Clases vacías, nombres de métodos definidos). Tú rellenas la lógica.
  • Temas probables: Métodos sobre Árboles (Actividad 2) o Grafos, siguiendo la lógica de manipular nodos y referencias.

4. Preguntas de Autoevaluación

  1. Sobre comparación de objetos: En el método search, ¿por qué debemos usar nodo.data.equals(valor) en lugar de nodo.data == valor?
  2. Sobre punteros en Pilas: Al realizar un push en una pila, ¿cuál es el orden correcto de asignación de punteros para no perder la referencia a la lista existente?
  3. Sobre Colas: Si tienes una Cola con un solo elemento y ejecutas remove(), ¿qué punteros deben actualizarse?
  4. Estrategia: ¿Qué penalización tiene usar java.util.LinkedList en el examen final?
  5. Entorno: ¿Qué debes hacer con tu IDE antes de comenzar el examen oficial?