Scribd Logo
Cargar

¡Te damos la bienvenida a Scribd!

  • Prácticas Estructuras Dinámicas

    Cargado por

    Amado Melguizo
    26 vistas6 páginas
    El documento presenta 10 ejercicios para implementar estructuras de datos dinámicas como pilas, colas y listas enlazadas simples y dobles utilizando clases en Java. Los ejercicios incluyen diseñar clases para pilas y colas estáticas utilizando arrays, implementar listas enlazadas simples con métodos como insertar y eliminar, y rediseñar una lista enlazada simple para mejorar la legibilidad del código. También propone implementar una agenda de teléfonos, colas y pilas dinámicas usando listas

    Descripción original:

    Derechos de autor

    © © All Rights Reserved

    Formatos disponibles

    PDF, TXT o lea en línea desde Scribd

    ¿Le pareció útil este documento?

    ¿Este contenido es inapropiado?

    Denunciar este documento
    El documento presenta 10 ejercicios para implementar estructuras de datos dinámicas como pilas, colas y listas enlazadas simples y dobles utilizando clases en Java. Los ejercicios incluyen diseñar clases para pilas y colas estáticas utilizando arrays, implementar listas enlazadas simples con métodos como insertar y eliminar, y rediseñar una lista enlazada simple para mejorar la legibilidad del código. También propone implementar una agenda de teléfonos, colas y pilas dinámicas usando listas

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd
    Marcar por contenido inapropiado
    Descargar como pdf o txt
    26 vistas6 páginas

    Prácticas Estructuras Dinámicas

    Cargado por

    Amado Melguizo
    El documento presenta 10 ejercicios para implementar estructuras de datos dinámicas como pilas, colas y listas enlazadas simples y dobles utilizando clases en Java. Los ejercicios incluyen diseñar clases para pilas y colas estáticas utilizando arrays, implementar listas enlazadas simples con métodos como insertar y eliminar, y rediseñar una lista enlazada simple para mejorar la legibilidad del código. También propone implementar una agenda de teléfonos, colas y pilas dinámicas usando listas

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd
    Marcar por contenido inapropiado
    Descargar como pdf o txt
    de 6

    EJERCICIOS 

     DE ESTRUCTURAS DINÁMICAS

    1) Diseña una clase para implementar una pila estática (los datos se 
    almacenarán en un array). 
    La pila guardará las letras del alfabeto. 
    Recuerda que en una pila los datos se almacenan y se recuperan en una posición
    denominada cima.  
    Las operaciones básicas que podemos hacer con una pila son:
    Insertar un elemento 
    Sacar un elemento.
    Detectar si está llena.
    Detectar si está vacía.

    Además de estas operaciones, escribiremos un método para rellenar la pila, 
    y otro para vaciarla. 
    El método que vacía la pila enviará a pantalla el elemento eliminado mientras la 
    pila  no esté vacía. La invocación de estas dos últimas operaciones se hará sin 
    utilizar un objeto.

    2) Diseña una clase para implementar una cola estática (los datos se 
    almacenarán en un array). 
    La cola guardará las letras del alfabeto. 
    Recuerda que en una cola los datos se insertan por el final y se eliminan por el 
    principio.  
    Las operaciones básicas que podemos hacer con una cola son:
    Insertar un elemento 
    Sacar un elemento.
    Detectar si está llena.
    Detectar si está vacía.

    Además de estas operaciones, escribiremos un método para rellenar la cola, 
    y otro para vaciarla. 
    El método que vacía la cola enviará a pantalla el elemento eliminado mientras la 
    cola  no esté vacía.

    3) Escribe las clases necesarias para implementar una lista enlazada 
    simple. Los métodos serán: insertarPrincipio, insertarFinal, buscar, 
    mostrarLista, eliminarNodo. 

    4) Vamos a rediseñar la clase ListaEnlazadaSimple del ejercicio anterior 
    para darle más legibilidad al código. De entrada para que facilitar las 
    cosas, los punteros o referencias inicio, anterior y actual serán miembros 
    datos. Además del constructor la clase contará con los siguientes 
    métodos:

    ­ listaVacia
    ­ finLista
    ­ insertarPrincipio. Deja anterior, inicio y actual apuntando donde 
    deban.
    ­ irPrincipio. Asigna a actual y anterior valores coherentes.
    ­ irSiguienteNodo. Avanza al siguiente nodo actualizando las 
    referencias anterior y actual.
    ­ getActual. Retorna la referencia del contenido del atributo inf del 
    nodo.
    ­ verLista. Muestra el contenido de la lista utilizando un bucle for y los 
    métodos descritos anteriormente.
    ­  Hace una búsqueda con un bucle for y los métodos descritos 
    anteriormente.
    ­ Eliminar. Recibe la referncia del objeto que quiere eliminar y 
    retorna un bolean.

    Prueba que funciona la clase con el Test siguiente:
    import java.io.*;

    public class TestListaES
    {
    public static void main(String args[])
    {
    ListaES lista = new ListaES();
    PrintStream pantalla = System.out;
    String nombres[] = {"pepe","maria","vivian"};
    for(int i=0; i<nombres.length; i++)
    lista.insertarPrincipio(nombres[i]);

    lista.verLista();
    pantalla.println("\n\n");
    String nombreEliminar = "pepe";
    boolean eliminado = lista.eliminar(nombreEliminar);
    if(eliminado)
    pantalla.println(nombreEliminar + "\nha sido 
    eliminado de la lista\n");

    lista.verLista();
    lista.insertarPrincipio("eduardo");
    pantalla.println("\n\n");
    lista.verLista();
    nombreEliminar = "vivian";
    eliminado = lista.eliminar(nombreEliminar);
    if(eliminado)
    pantalla.println(nombreEliminar + "\nha sido 
    eliminado de la lista\n");

    pantalla.println("\n\n");
    lista.verLista();
    }
    }

    5) Construye una agenda de teléfonos utilizando una lista enlazada simple. 
    Emplea un menú para actualizar la agenda.

    6) Implementa una cola utilizando una lista enlazada simple. La clase debe 
    llamarse ColaDinamica.

    7) Implementa una pila utilizando una lista enlazada simple. La clase debe 
    llamarse PilaDinamica.

    8) Diseña un interfaz denominado PilasColasDinamicas con los métodos 
    abstractos vacia, insertar y elimininar. Modifica los fuentes de los dos 
    ejercicios anteriores para que implementen el interfaz y construye un 
    TesTInterfazPilasColas para probar su funcionamiento.

    9) Dada la siguiente clase

    public class Nodo2 
    {
      public int clave;
      public String nombre;
      public Nodo2 sig;

      public Nodo2(int cl, String n)
      {
        clave = cl;
        nombre = n;
        sig = null;
      }
     
      public void mostrarNodo()
      {
         System.out.println("Clave: "+ clave+" Nombre "+nombre);
      }
    }

    Construye una clase denominada ListaOrdenada con los siguientes métodos:

    ­ public void insertar(int clave, String nombre). Inserta en la lista de forma 
    que se ordene de menor a mayor por la clave.
    ­ Borrar. Recibe la clave del elemento a eliminar.
    ­ Buscar. Recibe la clave del elemento a buscar
    ­ MostrarLista.

    10) El siguiente fuente se utiliza para implementar una lista enlazada doble.

    class NodoDoble
    {
    private Object inf;
    private NodoDoble ant;
    private NodoDoble sig;

    //constructor
    public NodoDoble( Object obj )
    {
    ant = null;
    sig = null;
    inf = obj;
    }

    //metodos set
    public void setAnt( NodoDoble n )
    {
    ant = n;
    }

    public void setSig( NodoDoble n )
    {
    sig = n;
    } 
    public void setInf( Object obj )
    {
    inf = obj;
    }

    //metodos get
    public NodoDoble getAnt()
    {
    return ant;
    }

    public NodoDoble getSig()
    {
    return sig;
    }

    public Object getInf()
    {
    return inf;
    }
    }

    Construye un fuente denominado ListaEnlazadaDoble donde los miembros datos 
    sea: inicio, fin y numElema. La clase, además del constructor tendrá los siguientes 
    métodos:

    ­ setIncio.
    ­ setFin.
    ­ getInicio.
    ­ getFin.
    ­ listaVacia.
    ­ insertarPrincipio.
    ­ insertarFinal
    ­ buscar
    ­ eliminar.
    ­ mostarListaPrincipio. Muestra la lista empezando a recorrerla por el 
    principio.
    ­ mostrarListaFinal. Muestra la lista empezando a recorrerla por el final.

    Para probar la clase utilizaremos el Test siguiente:

    class TestListaEnlazadaDoble
    {
    public static void main ( String args[] )
    {
    ListaEnlazadaDoble lista1 = new ListaEnlazadaDoble();

    for( char c = 'a'; c <= 'f'; c++ )
    {
    Character car = new Character(c);
    lista1.insertarFinal(car);
    }

    System.out.println("\n Lista de principio a fin...");
    lista1.mostrarListaPrincipio();
    System.out.println("\n Lista de fin a principio...");
    lista1.mostrarListaFinal();

    Character letra = 'z';// Ojo como se lo come 
    System.out.println("\n Insertar al principio: " + letra );
    lista1.insertarPrincipio(letra);
    lista1.mostrarListaPrincipio();

    System.out.println("\n Eliminar el primero: z");
    lista1.eliminar('z');
    lista1.mostrarListaPrincipio();

    System.out.println("\n Eliminar el ultimo: f");
    lista1.eliminar('f');
    lista1.mostrarListaPrincipio();

    System.out.println("\n Eliminar en medio: c");
    lista1.eliminar('c');
    lista1.mostrarListaPrincipio();

    System.out.println("\n Eliminar uno cualquiera: g");
    lista1.eliminar('g');
    lista1.mostrarListaPrincipio();

    ListaEnlazadaDoble lista2 = new ListaEnlazadaDoble();
    }
    }

    También podría gustarte