Unidad 2 Estructuras de Datos Lineales (Pilas y Colas)

 Objetivo: Identificar las características y funcionamiento de pilas y colas.

 Instrucciones:

  • Revisa estos videos animados sobre el funcionamiento de las pilas y las colas.
  • Revisa el video con la explicación de las operaciones y los tipos para realizar los métodos sobre Pilas y Colas a los que les sean solicitados considerando únicamente usar las operaciones de los TDA sin considerar la forma de almacenamiento interno.
  • Revisa los ejemplos de pila y cola estática y modificar el método mostrar de cada estructura para que sea correcto. 
  • Realiza los ejercicios de pilas y colas siguientes de acuerdo a los miembros del grupo
    • ALBERTO TOLENTINO, ANGEL M:
      • realizar un método que reciba dos pilas y al final del método las dos pilas deben tener el contenido intercambiado.
      • realizar un método que reciba una cola de enteros y guarde en un arreglo sus valores pares
    • BENITEZ JUAREZ, MARCO ANTONIO.
      • realizar un método que muestre los elementos  que tiene una pila(al final la pila debe tener su contenido original)
      • realizar un método que reciba una cola  y guarde en una matriz su contenido
    • BLANCO ACOSTA, MANOLO E:
      • realizar un método que reciba dos colas y al final del método las dos colas deben tener el contenido intercambiado.
      • realizar un método que reciba un arreglo de enteros y guarde en un pila sus valores pares
    • CASTILLO GUZMAN, IAN Y:
      • realizar un método que cuente cuántos elementos tiene una pila
      • realizar un método que reciba un arreglo, una pila y una cola, de tal manera que los valores con contenido par del arreglo se guarden en una cola y los impares en la pila.
    • CRUZ VAZQUEZ, ERIK I:
      • realizar un método que reciba una cola, dentro del método el contenido de la cola se guardará en un arreglo con sólo el primer y el último elemento de la cola
      • realizar un método que reciba una cola y una lista ligada simple y devuelva true si tienen los mismos elementos o false en caso contrario
    • FLORES SERRANO, JESUS A.:
      • realizar un método que reciba una cola y un arreglo de enteros y guarde el contenido del arreglo en la cola
      • realizar un método que verifique si dos pilas contienen los mismos elementos, devolviendo true o false de acuerdo al caso
    • GARATE CRUZ, SEBASTIAN D.:
      • realizar un método que reciba una cola y una pila y al final del método el contenido de las estructuras quede intercambiado.
      • realizar un método que reciba una pila de enteros y devuelva el resultado de multiplicar todos los datos.
    • GARCIA MARTINEZ, LUIS ANTONIO:
      • realizar un método que cuente cuántos elementos tiene una cola
      • realizar un método que reciba un arreglo, una pila y una cola, de tal manera que los los datos de la pila y de la cola se guarden en el arreglo que estaría vacío previamente
    • LEZAMA CRUZ, JOSE M:
      • realizar un método que reciba una pila y una cola, dentro del método el contenido de la pila se agregara a la cola.(resuelto por maestra)
      • realizar un método que reciba una pila y una cola y devuelva true si tienen los mismos elementos en sentido inverso o devuelva false en caso contrario.
      • realizar un método que que guarde en una lista ligada el contenido de una pila y de una cola de forma altenada hasta que se vacíe el contenido de la pila y la cola(nuevo ejercicio asignado)
    • LOPEZ VICENTE, WEYMAN N:
      • realizar un método que reciba una cola y una pila de enteros  y al final del método se muestre el valor de cada elemento de la cola elevado al exponente del contenido de la pila.
      • realizar un método que reciba una pila de enteros y modifique la estructura para que solo queden en la pila los contenidos con valor par.
    • MENDOZA HERNANDEZ, DANIEL:
      • realizar un método que reciba una cola y una pila de enteros  y al final del método se muestre el valor de cada elemento de la pila elevado al exponente del contenido de la cola.
      • realizar un método que reciba una cola de enteros y modifique la estructura para que solo queden en la cola los contenidos con valor par.
    • MORA CONTRERAS, CARLOS U:
      • realizar un método que reciba una pila de enteros y devuelva la suma de su contenido
      • realizar un método que reciba una pila y una cola, dentro del método el contenido de la pila se agregara a la cola.
    • OSIO CARMONA, FERNANDO D:
      • realizar un método que muestre los elementos  que tiene una cola(al final la cola debe tener su contenido original)
      • realizar un método que reciba una pila  y guarde en una matriz su contenido
    • PALENCIA VAZQUEZ, HUGO A.:
      • realizar un método que reciba una pila y un dato y devuelva true si ese dato está dentro de la pila al menos una vez o false en caso contrario
      • realizar un método que reciba un archivo de enteros y guarde en una cola el contenido
    • PEREZ ARCE, GABRIELA:
      • realizar un método que reciba una pila y una cola, dentro del método el contenido de la cola se agregara a la pila.
      • realizar un método que reciba dos colas y devuelva true si son iguales elemento a elemento o devuelva false en caso contrario.
    • RAMIREZ LUIS, CESAR J.:
      • realizar un método que reciba una pila y se guarde en otra pila todos sus datos salvo el primer elemento de la pila
      • realizar un método que reciba una pila y una lista ligada simple y devuelva true si tienen los mismos elementos o false en caso contrario
    • RAMOS ROJAS, EMMANUEL:
      • realizar un método que reciba una pila y su contenido se guarde en una lista ligada simple
      • realizar un método que reciba una cola de enteros y guarde en un archivo los datos de la cola que no sean datos del inicio ni del final, sólo los de enmedio.
    • RODRIGUEZ MARTINEZ, ADRIAN: 
      • realizar un método que reciba una pila y una cola, dentro del método el contenido de la cola salvo el primero y el último elemento se agregara a la pila.
      • realizar un método que reciba una cola y una lista ligada simple y se guarde el contenido de la lista en la cola.
    • ROMERO DE LA ROSA ALEXIS
      • Realizar un método que reciba una cola y un dato y devuelva true si ese dato
        está dentro de la cola al menos una vez o false en caso contrario.
      • Realizar un método que reciba un archivo de enteros y guarde en una pila el
        contenido.
    • TRINIDAD FLORES ALEJANDRO
      • Método que recibe una pila y un arreglo de enteros y guarda el contenido del arreglo en la pila.
      • método que verifica si una cola y una pila contienen los mismos elementos, devolviendo true o false de acuerdo al caso
  •  Nota se asume que la pila y la cola ya existen como estructuras por lo que los métodos a realizar únicamente emplean las operaciones de la pila o la cola y no su implementación interna, por lo que no es válido que desde sus métodos solicitados accedan a las posiciones del arreglo y si obtienen información de las estructuras recuerden respaldar para no perder la información. Al momento todas sus implementaciones tendrán una implementación interna de arreglos aún no se puede implementar con listas ligadas hasta que revisemos el tema de listas.
Evidencia
únicamente métodos en java o c 

Comentarios

  1. Hugo Antonio Palencia Vázquez10 de junio de 2025 a las 8:32

    Este comentario ha sido eliminado por el autor.

    ResponderEliminar
  2. Alejandro Trinidad Flores10 de junio de 2025 a las 9:06

    Método que recibe una pila y un arreglo de enteros y guarda el contenido del arreglo en la pila.

    *Parte importante del código 1:

    public class PilaHelper {

    // Recibe una pila y una cola con los elementos y los guarda en la pila
    public static void guardarEnPila(Stack pila, Queue cola) {
    while (!cola.isEmpty()) {
    pila.push(cola.poll()); // "poll" saca el elemento del frente de la cola
    }
    }

    *Archivo completo que contiene el primer código completo y también el segundo:
    https://drive.google.com/file/d/1YT9mkT_62sagjre1KSQvBv5GXharrLvy/view?usp=sharing

    Nota: el segundo código es un método que verifica si una cola y una pila contienen los mismos elementos, devolviendo true o false de acuerdo al caso

    ResponderEliminar
  3. Hugo Antonio Palencia Vázquez12 de junio de 2025 a las 22:15

    //metodo que reciba una pila y un dato y devuelva true si ese dato está dentro de la pila al menos una vez o false en caso contrario
    int estaEnPila(Pila P,int v){
    int a;
    do{
    if(esVaciaPila(P))break;
    P=pop(P,&a);
    }while (a!=v);
    return a==v;

    }
    //realizar un método que reciba un archivo de enteros y guarde en una cola el contenido

    Cola archivoACola(char* nombreArchivo){
    Cola C=CrearCola();
    int v=0;
    FILE* F=fopen(nombreArchivo,"r");
    if(F==NULL){
    printf("Error al abrir el archivo");
    }

    while(!feof(F)){

    fscanf(F,"%d",&v);
    C=encolar(C,v);
    }
    fclose(F);
    return C;

    }

    ResponderEliminar
  4. Fernando de Jesus Osio Carmona17 de junio de 2025 a las 7:57

    1. Método para mostrar elementos de una cola (conservando contenido original)
    void mostrarCola(Cola C) {
    Cola temp = CrearCola(); // Cola temporal para preservar los datos
    int valor;

    // Vaciar cola original mostrando elementos
    while(!esVaciaCola(C)) {
    C = desencolar(C, &valor); // Extraer elemento del frente
    printf("%d ", valor); // Mostrar elemento
    temp = encolar(temp, valor); // Guardar en temporal
    }

    // Restaurar cola original
    while(!esVaciaCola(temp)) {
    temp = desencolar(temp, &valor);
    C = encolar(C, valor);
    }
    }
    2. Método para guardar contenido de una pila en una matriz
    void pilaAMatriz(Pila P, int matriz[][MAX_MATRIZ], int filas, int columnas) {
    Pila temp = CrearPila(); // Pila temporal para invertir orden
    int valor;
    int i = 0, j = 0;

    // Volcar pila original a temporal (invierte el orden)
    while(!esVaciaPila(P)) {
    P = pop(P, &valor);
    temp = push(temp, valor);
    }

    // Llenar matriz desde la pila temporal
    while(!esVaciaPila(temp) && i < filas) {
    temp = pop(temp, &valor);
    matriz[i][j] = valor;
    j++;
    if(j >= columnas) { // Cambiar de fila
    j = 0;
    i++;
    }
    }

    // Rellenar espacios vacíos con 0 si es necesario
    while(i < filas) {
    while(j < columnas) {
    matriz[i][j] = 0;
    j++;
    }
    j = 0;
    i++;
    }

    // Restaurar pila original (opcional, ya que trabajamos con copia)
    while(!esVaciaPila(temp)) {
    temp = pop(temp, &valor);
    P = push(P, valor);
    }
    }
    Nota 2do método: No respaldar el contenido

    ResponderEliminar
  5. Alexis Romero [LIZZARD]17 de junio de 2025 a las 12:12

    1. Realizar un método que reciba una cola y un dato y devuelva true si ese dato
    está dentro de la cola al menos una vez o false en caso contrario.

    2. import java.util.LinkedList;
    3. import java.util.Queue;
    4.
    5. public class BusquedaEnCola {
    6.
    7. public static boolean contiene(Queue cola, T datoBuscado) {
    8. // Verificar si la cola es nula
    9. if (cola == null) {
    10. return false;
    11. }
    12.
    13. // Recorrer la cola sin modificarla
    14. for (T elemento : cola) {
    15. // Comparar el elemento actual con el dato buscado
    16. if (datoBuscado == null ? elemento == null :
    datoBuscado.equals(elemento)) {
    17. return true;
    18. }
    19. }
    20.
    21. // Si no se encontró el dato
    22. return false;
    23. }
    24.
    25. public static void main(String[] args) {
    26. // Ejemplo de uso
    27. Queue colaStrings = new LinkedList<>();
    28. colaStrings.add("Capa");
    29. colaStrings.add("Alma");
    30. colaStrings.add("Sombra");
    31.
    32. System.out.println("¿La vasija tiene Alma? " +
    contiene(colaStrings, "Alma")); // true
    33. System.out.println("¿La vasija tiene Geo? " +
    contiene(colaStrings, "Geo")); // false
    34.
    35. Queue colaEnteros = new LinkedList<>();
    36. colaEnteros.add(10);
    37. colaEnteros.add(20);
    38. colaEnteros.add(30);
    39.
    40. System.out.println("¿Contiene 20? " + contiene(colaEnteros, 20));
    // true
    41. System.out.println("¿Contiene 50? " + contiene(colaEnteros, 50));
    // false
    42. }
    43. }

    ResponderEliminar
  6. Alexis Romero [LIZZARD]17 de junio de 2025 a las 12:13

    2. Realizar un método que reciba un archivo de enteros y guarde en una pila el
    contenido.
    3. import java.io.File;
    4. import java.io.FileNotFoundException;
    5. import java.util.Scanner;
    6. import java.util.Stack;
    7.
    8. public class ArchivoAPila {
    9.
    10. public static Stack leerEnterosYPonerEnPila(String
    nombreArchivo) {
    11. Stack pila = new Stack<>();
    12.
    13. try {
    14. File archivo = new File(nombreArchivo);
    15. Scanner scanner = new Scanner(archivo);
    16.
    17. while (scanner.hasNext()) {
    18. if (scanner.hasNextInt()) {
    19. int numero = scanner.nextInt();
    20. pila.push(numero);
    21. } else {
    22. scanner.next();
    23. }
    24. }
    25.
    26. scanner.close();
    27. } catch (FileNotFoundException e) {
    28. System.err.println("Error: Archivo no encontrado - " +
    e.getMessage());
    29. }
    30.
    31. return pila;
    32. }
    33.
    34. public static void main(String[] args) {
    35. // Ruta relativa al archivo (debe estar en la raíz del proyecto)
    36. String nombreArchivo = "numeros.txt";
    37.
    38. // Llamada al método
    39. Stack pilaNumeros =
    leerEnterosYPonerEnPila(nombreArchivo);
    40.
    41. // Mostrar resultados
    42.
    43.
    if (pilaNumeros.isEmpty()) {
    System.out.println("La pila está vacía. ¿El archivo contenía
    números?");
    44.
    } else {
    45.
    System.out.println("Elementos en la pila (orden LIFO - último
    en entrar, primero en salir):");
    46.
    while (!pilaNumeros.empty()) {
    47.
    System.out.println(pilaNumeros.pop());
    48.
    }
    49.
    }
    50.
    }
    51. }
    Archivo txt de los números enteros:
    7
    0
    xdxd
    30
    77
    Lizzard
    9999

    ResponderEliminar
  7. Gaby Pérez17 de junio de 2025 a las 14:57

    Link del drive con los códigos completos:
    https://drive.google.com/drive/folders/1eb0eqDBWsC_I_aHZW0ljk_eOvx92QI1d?usp=sharing

    ResponderEliminar
  8. Adrián Rodríguez 17 de junio de 2025 a las 21:48

    Realizar un método que reciba una pila y una cola, dentro del método el contenido de la cola salvo el primero y el último elemento se agregara a la pila:
    // -----------
    public static void intermediosColaAPila(cola c, Pila p) {
    cola respaldo = new cola(50);
    int contador = 0;

    while (c.vacia() == 0) {
    int x = c.extraer();
    respaldo.insertar(x);
    contador++;
    }

    for (int i = 0; i < contador; i++) {
    int x = respaldo.extraer();
    if (i > 0 && i < contador - 1) {
    p.push(x);
    }
    c.insertar(x);
    }
    }

    ResponderEliminar
  9. Adrián Rodríguez 17 de junio de 2025 a las 21:51

    Realizar un método que reciba una cola y una lista ligada simple y se guarde el contenido de la lista en la cola:
    public static void listaACola(ListaLigadaSimple lista, cola c) {
    Nodo actual = lista.cabeza;

    //Recorrer la lista y meter cada dato directamente a la cola
    while (actual != null) {
    c.insertar(actual.dato);
    actual = actual.siguiente;
    }
    }

    public static void main(String[] args) {
    ListaLigadaSimple lista = new ListaLigadaSimple();
    cola miCola = new cola(10);

    //Insertamos en la lista, osea se insertan al inicio
    lista.insertar(10);
    lista.insertar(20);
    lista.insertar(30); //Lista

    System.out.print("Lista ligada: ");
    lista.mostrar();

    // Se transfiere de forma directa a la cola
    listaACola(lista, miCola);

    miCola.mostrar("Cola con los elementos de la lista:");
    }
    }

    ResponderEliminar
  10. Luis Antonio18 de junio de 2025 a las 21:35


    Realiza los ejercicios de pilas y colas siguientes de acuerdo a los miembros del grupo
    • GARCIA MARTINEZ, LUIS ANTONIO:
    o realizar un método que cuente cuántos elementos tiene una cola
    o realizar un método que reciba un arreglo, una pila y una cola, de tal manera que los los datos de la pila y de la cola se guarden en el arreglo que estaría vacío previamente
    import java.util.LinkedList;
    import java.util.Queue;

    public class ColaUtil {

    // Método que cuenta los elementos de una cola sin modificarla
    public static int contarElementosCola(Queue cola) {
    int contador = 0;
    Queue temporal = new LinkedList<>();

    while (!cola.isEmpty()) {
    int elemento = cola.poll();
    temporal.add(elemento);
    contador++;
    }

    // Restaurar la cola original
    while (!temporal.isEmpty()) {
    cola.add(temporal.poll());
    }

    return contador;
    }
    }





























    import java.util.Stack;
    import java.util.Queue;
    import java.util.LinkedList;

    public class MezclarEstructuras {

    // Método que copia los elementos de pila y cola a un arreglo
    public static int[] combinarPilaCola(Stack pila, Queue cola) {
    int totalElementos = pila.size() + cola.size();
    int[] arreglo = new int[totalElementos];
    int index = 0;

    // Extraer de la pila (LIFO)
    Stack pilaTemporal = new Stack<>();
    while (!pila.isEmpty()) {
    int valor = pila.pop();
    pilaTemporal.push(valor); // Para no perder el valor original
    arreglo[index++] = valor;
    }

    // Restaurar la pila original
    while (!pilaTemporal.isEmpty()) {
    pila.push(pilaTemporal.pop());
    }

    // Extraer de la cola (FIFO)
    Queue colaTemporal = new LinkedList<>();
    while (!cola.isEmpty()) {
    int valor = cola.poll();
    colaTemporal.add(valor); // Guardar para restaurar después
    arreglo[index++] = valor;
    }

    // Restaurar la cola original
    while (!colaTemporal.isEmpty()) {
    cola.add(colaTemporal.poll());
    }

    return arreglo;
    }
    }

















    import java.util.Stack;
    import java.util.Queue;
    import java.util.LinkedList;
    import java.util.Arrays;

    public class Main {

    public static void main(String[] args) {
    // Crear y llenar la pila
    Stack pila = new Stack<>();
    pila.push(10);
    pila.push(20);
    pila.push(30);

    // Crear y llenar la cola
    Queue cola = new LinkedList<>();
    cola.add(100);
    cola.add(200);
    cola.add(300);

    // Contar elementos de la cola
    int cantidad = ColaUtil.contarElementosCola(cola);
    System.out.println("Cantidad de elementos en la cola: " + cantidad);

    // Combinar pila y cola en un arreglo
    int[] resultado = MezclarEstructuras.combinarPilaCola(pila, cola);
    System.out.println("Arreglo combinado: " + Arrays.toString(resultado));
    }
    }
    https://drive.google.com/file/d/13Y6qA2h9sW2nUUZx8NGOBXM2IC4ZKOFL/view?usp=sharing

    ResponderEliminar
  11. Alberto Tolentino Angel Michel20 de junio de 2025 a las 6:47

    link con los dos codigos
    https://drive.google.com/file/d/1hop-xDjjgOhLLZkavDlrhgwhgiwtZe-m/view?usp=sharing

    ResponderEliminar
  12. NICOLAS LOPEZ VICENTE24 de junio de 2025 a las 22:19

    link de los 2 codigos;
    https://drive.google.com/drive/folders/12W5LgICGokShlSo10izRDFwPvta-_UY6?usp=drive_link

    ResponderEliminar

Publicar un comentario

Entradas populares de este blog

Unidad 3 Grafos

Imagen
  Objetivo Representar la información relacionada con Grafos y realizar el recorrido a lo profundo Instrucciones Revisar las  diapositivas  de Grafos sobre los conceptos más importantes(repaso de matemáticas discretas) Tomar nota de la representación con matriz de adyacencia y con lista de adyacencia Obtener las propiedades del grafo enviado por correo: número de nodos, número de aristas, un camino simple, un ciclo, el grado de los nodos y la matriz de adyacencia Revisar el  video  de recorrido a lo profundo  o las  diapositivas Revisar el  video  sobre recorrido a lo ancho o las  diapositivas  Implementar mediante matriz de adyacencia el método solicitado a cada miembro del grupo Realizar la prueba de escritorio del recorrido a lo profundo del grafo asignado. Nota recuerden que es prueba de escritorio por eso no indica programar o implementar Ejercicios asignados: ALBERTO TOLENTINO, ANGEL M: Obtener las propiedades del  g...
Leer más

Unidad 1 Introducción a las estructuras de Datos

Imagen
  Objetivo:  Relacionar la importancia de los TDA para la definición de estructuras de datos  Instrucciones: Revisar el video con la presentación sobre las estructuras de datos  https://www.youtube.com/watch?v=Aqftq6nlgnM  y analizar si hay algún error Revisar la imagen del TDA bolsa Investigar o modelar las estructuras de datos asignadas que estén estructuradas de forma similar como la imagen que representa el TDA Bolsa o lo más cercano posible, estas son las estructuras asignadas al grupo (aquí se asignarán los ejercicios a cada quien) ALBERTO TOLENTINO, ANGEL M: buscar el tda trie(conjuntos de palabras) con sus operaciones asociadas (no implementación sino definiciones como en la bolsa) BENITEZ JUAREZ, MARCO ANTONIO: buscar el tda archivo con sus operaciones asociadas (no implementación sino definiciones como en la bolsa) BLANCO ACOSTA, MANOLO E: buscar el tda cuadtree(representación de imágenes) con sus operaciones asociadas (no implementación sino definicio...
Leer más

Unidad 4. Árboles Binarios

Imagen
       Objetivo Identificar las ventajas de emplear árboles binarios Instrucciones Revisar los videos de explicación de los árboles binarios de búsqueda ÁrbolesBinariosConsideraciones Recorridos Eliminación de nodos  primera  y  segunda  parte EjemploArbolBinario Pueden revisar las  diapositivas  o emplearlas de base para su prueba de escritorio Revisar el  ejemplo  arbolbin1.java donde vienen métodos de ejemplo Ejemplo de un árbol que no es correcto, explicar porque en la sesión de revisión Realizar los ejercicios: ALBERTO TOLENTINO, ANGEL M:  Realizar la prueba de escritorio paso a paso de la eliminación del valor 20   (No implementado) y del recorrido inorden del subárbol derecho del árbol. Considerando un árbol binario, implementar un método que muestre cuantos nodos  son nodos hojas y cuantos no. BENITEZ JUAREZ, MARCO A: Realizar la prueba de escritorio paso a paso de la búsqueda del valor 100...
Leer más