Implementar pilas

Hola necesito ayuda urgente porque tengo que hacer en java: implementar una cola, una pila y una lista circular usando una lista como estructura que almacene los datos
Soy incapaz y se me termina el plazo
(Tengo que ver que funcionan con algún problemilla)
Gracias por anticipado
5

5 respuestas

1
Respuesta de
Si lo que tienes es que implementar una cola de peticiones que realicen acciones, te recomiendo 2 cosas.
1. Crea una clase que herede de thread y que puedas lanzar en un hilo de ejecución independiente.
En el método init() inicia una variable a true.
En run() un bucle while (variable) y dentro del bucle llamas a 3 funciones.
En el método stop() la variable a false.
Esta clase debe contener un Hashtable para almacenar peticiones.
2. En el primer método accede a las peticiones (si están en una base de datos la lees, lees fichero externos, etc) y las almacenas en la hastable.
3. En el segundo proceso procesas las peticiones (enviando e-mail o lo que hagas) por lo que dentro del bucle habrá otro que recorra la lista.
4. El tercer método tiene de entrada un check de petición procesada o no. Si la petición es OK la borras de la hashtable y de tablas, fichero, etc. Si es KO controlas el número de intentos para descartarla en caso de superar un límite.
Por último la clase run tiene un método sleep para parar cuando la lista esté vacía.
El Run es independiente, debes arrancarlo y pararlo desde otra clase (por ejemplo desde el método init() y destroy() de un servlet si estás en un entorno web).
Un saludo.
Necesito implementar estructuras de datos para los TDA pila, cola y lista Circular utilizando una lista como estructura que almacene los datos y ver que funcionan con algún ejm sencillo.
Parece ser fácil pero soy incapaz, según me dicen que hay que usar el borrar vacía insertar sacer,,,, Es decir no crear la cola, parece ser que hay que usar la lista y solo definir esas operaciones y que la cola, pila lista circular se basen en la lista
ES UN LIO
Parece que lo que tienes que usar es la clase java. Útil. Vector() que tiene métodos addElement(Object), setElementAt(), removeElement(), etc.
Como los Vector son listas de "objetos" en general pueden añadir cualquier tipo de cosas. Incluso una clase de "datos".
Lo mejor es que crees tu propia clase heredando de esta, así le puedes añadir los métodos accesorios que necesites además de tener los propios.
Añade un comentario a esta respuesta
1
Respuesta de
¿No eres capas de crear las estructuras o los algoritmos?
Necesito implementar estructuras de datos para los TDA pila, cola y lista Circular utilizando una lista como estructura que almacene los datos y ver que funcionan con algún ejm sencillo.
Parece ser fácil pero soy incapaz, según me dicen que hay que usar el borrar vacía insertar sacer,,,, Es decir nocrearlacola, parece ser que hay que usar la lista y solo definir esas operaciones y que la cola, pila lista circular se basen en la lista
ES UN LIO
¿Puedes listarme las cosas que hay que hacer?
Necesito un programa que sea una pila pero no creada como tal sino que use la pila, supongo que hay que crear la pila haciendo llamadas a la lista, lo mismo para la cola y para la lista circular
Uups
Me dicen que es fácil, pero mi java es pésimo
no hay que crear la pila como tal, solo definirlas funciones de añadir, insertar ... y haciendo llamadas a la pila que es donde esta creada la estructura
me parece que es usando el interfaz pila o algo así
Debes tener definida tu estructura del nodo. ¿Puedes enviármela?
import lista.*;
/*************************************************************************************
* Ejemplo de uso de una lista implementada sobre un vector. *
* En el paquete lista (importado en la primera línea) se encuentran las clases: *
* Lista: un interfaz para la lista. *
* ListaSecuencial: una clase que implementa el interfaz lista. *
* Verificar: una clase que lanza excepciones de tipo IllegalArgumentException. *
* *
* Las funciones de la interfaz Lista que se utilizan en este ejemplo son: *
* añadir (Object): añade un objeto al final de la lista. *
* imprimir (): vuelca el contenido de la lista en la pantalla. *
* mover (int): mueve el cursor a la posición inidicada. *
* insertar (Object): inserta el objeto en la posición actual del cursor. *
* eliminar (): elimina el objeto de la posición actual de la lista. *
* ppio (): mueve el cursor al primer elemento de la lista. *
* dentro (): comprueba si el cursor apunta a un elemento de la lista. *
* siguiente (): avanza una posición el cursor, al siguiente elemento de la lista. *
* borrar (): borra el contenido de la lista. *
* *
* Otras funciones utilizadas en el programa: *
* System.out.println (Object): muestra el contenido del objeto por pantalla. *
* En este caso se ha utilizado para mostrar, *
* cadenas explicativas por pantalla. *
*************************************************************************************/
public class prueba {
public static void main (String [] args) {
Lista lista = new ListaSecuencial ();
System.out.println (">> Tenemos una lista vacia.");
System.out.println (">> La imprimimos para comprobarlo.");
lista.imprimir ();
System.out.println (">> A la lista vacia le añadimos elementos.");
lista.añadir ("Uno"); // adicción de un elemento, al final de la lista
lista.añadir ("Dos");
lista.añadir ("Tres");
System.out.println (">> Imprimimos la lista para ver que contiene ahora.");
lista.imprimir ();
System.out.println (">> Añadimos un nuevo elemento.");
lista.añadir ("Cuatro");
lista.imprimir ();
System.out.println (">> Insertamos un elemento mas al principio.");
lista.mover (0);
lista.insertar ("Cinco");
lista.imprimir ();
System.out.println (">> Y otro mas al final.");
lista.añadir ("Seis");
lista.imprimir ();
System.out.println (">> Mover el cursor no afecta. Siempre se puede añadir al final.");
System.out.println (">> Ahora probamos a eliminar el elemento de indice 1 de la lista.");
lista.mover (1);
lista.eliminar ();
lista.imprimir ();
System.out.println (">> Recorremos la lista. Para demostrarlo imprimimos cada elemento por separado");
for (lista.ppio (); lista.dentro (); lista.sgte ())
System.out.println ("\t" + lista.obtener ());
System.out.println (">> Para terminar la prueba la borramos.");
lista.borrar ();
lista.imprimir ();
}
}
Sabes, te puedo ayudar, pero mi problema es el tiempo, te lo podría tener para mañana a las 5 de la tarde hora de Chile. Es mejor que nos comuniquemos por correo. ¿l mio es benvenuto@esfera.cl
ok?
Añade un comentario a esta respuesta
1
Respuesta de
Hola
Te anticipo que no soy un megaexperto de Java precisamente, pero creo que puedo ayudarte.
Para hacer una pila (LIFO) en java, tengo aquí tu ejercicio resuelto:
http://enterprise.eui.upm.es/grupos/EjercicioJava.pdf
Para una cola (FIFO), creo que esto te vale:
import java.io.*;
interface Queue {
public void enqueue(Object o);
public Object dequeue();
}
class LinkedQueue implements Queue {
Node top, bottom;
public void enqueue(Object o) {
Node n = new Node(o);
if (bottom != null) {
bottom.next = n;
bottom = n;
} else
top = bottom = n;
}
public Object dequeue() throws NullPointerException {
Object o = top.elem;
top = top.next;
if (top == null)
bottom = null;
return o;
}
class Node {
private Object elem;
private Node next;
public Node(Object o) {
this.elem = o;
}
}
}
class MyMain1 {
public static void main(String args[]) {
FileReader f;
StringWriter g = new StringWriter();
LinkedQueue h = new LinkedQueue();
try {
f = new FileReader(args[0]);
} catch(FileNotFoundException e) {
return;
}
for (int c = 0; c != -1; ) {
try {
c = f.read();
} catch (IOException e) {
c = -1;
}
switch (c) {
case -1 : if (g.getBuffer().length() > 0) {
h.enqueue(g.getBuffer().toString());
g.getBuffer().setLength(0);
}
break;
case '\n': h.enqueue(g.getBuffer().toString());
g.getBuffer().setLength(0);
continue;
default : g.write(c);
continue;
}
}
while (true) {
String s;
try {
s = (String)h.dequeue();
System.out.println(s);
} catch(NullPointerException e) {
break;
}
}
}
}
Para una lista circular, creo que en este largísimo enlace tienes lo que necesitas:
http://mailweb.udlap.mx/~ccastane/Syllabus_Estructura_Datos/Notas_Estr_Datos/Ejemplos/TercerParcial/Ejem_ListasLigCircular.html
Puede que estas cosas, aunque tengo la sospecha de que no he entendido bien la pregunta. ¿Quieres crear todas estas estructuras a partir de una lista? Es decir, ¿Quieres usar la pila, lista y cola como interface para manejar una lista? Si es así, puedo ayudarte algo más de lo que he hecho.
Saludos
Necesito implementar estructuras de datos para los TDA pila, cola y lista Circular utilizando una lista como estructura que almacene los datos y ver que funcionan con algún ejm sencillo.
Parece ser fácil pero soy incapaz, según me dicen que hay que usar el borrar vacía insertar sacer,,,, Es decir nocrearlacola, parece ser que hay que usar la lista y solo definir esas operaciones y que la cola, pila lista circular se basen en la lista
ES UN LIO, creo que es lo del interfaz
Parece ser que es algo parecido a esto o que se basa en esto
eSTO ES LA BASE DE LO QUE TENGO QUE HACER,ESTRUCTURA DE UNA PILA BASANDOME EN ESTA LISTA YA CREADAimport lista.*;
/*************************************************************************************
* Ejemplo de uso de una lista implementada sobre un vector. *
* En el paquete lista (importado en la primera línea) se encuentran las clases: *
* Lista: un interfaz para la lista. *
* ListaSecuencial: una clase que implementa el interfaz lista. *
* Verificar: una clase que lanza excepciones de tipo IllegalArgumentException. *
* *
* Las funciones de la interfaz Lista que se utilizan en este ejemplo son: *
* añadir (Object): añade un objeto al final de la lista. *
* imprimir (): vuelca el contenido de la lista en la pantalla. *
* mover (int): mueve el cursor a la posición inidicada. *
* insertar (Object): inserta el objeto en la posición actual del cursor. *
* eliminar (): elimina el objeto de la posición actual de la lista. *
* ppio (): mueve el cursor al primer elemento de la lista. *
* dentro (): comprueba si el cursor apunta a un elemento de la lista. *
* siguiente (): avanza una posición el cursor, al siguiente elemento de la lista. *
* borrar (): borra el contenido de la lista. *
* *
* Otras funciones utilizadas en el programa: *
* System.out.println (Object): muestra el contenido del objeto por pantalla. *
* En este caso se ha utilizado para mostrar, *
* cadenas explicativas por pantalla. *
*************************************************************************************/
public class prueba {
public static void main (String [] args) {
Lista lista = new ListaSecuencial ();
System.out.println (">> Tenemos una lista vacia.");
System.out.println (">> La imprimimos para comprobarlo.");
lista.imprimir ();
System.out.println (">> A la lista vacia le añadimos elementos.");
lista.añadir ("Uno"); // adicción de un elemento, al final de la lista
lista.añadir ("Dos");
lista.añadir ("Tres");
System.out.println (">> Imprimimos la lista para ver que contiene ahora.");
lista.imprimir ();
System.out.println (">> Añadimos un nuevo elemento.");
lista.añadir ("Cuatro");
lista.imprimir ();
System.out.println (">> Insertamos un elemento mas al principio.");
lista.mover (0);
lista.insertar ("Cinco");
lista.imprimir ();
System.out.println (">> Y otro mas al final.");
lista.añadir ("Seis");
lista.imprimir ();
System.out.println (">> Mover el cursor no afecta. Siempre se puede añadir al final.");
System.out.println (">> Ahora probamos a eliminar el elemento de indice 1 de la lista.");
lista.mover (1);
lista.eliminar ();
lista.imprimir ();
System.out.println (">> Recorremos la lista. Para demostrarlo imprimimos cada elemento por separado");
for (lista.ppio (); lista.dentro (); lista.sgte ())
System.out.println ("\t" + lista.obtener ());
System.out.println (">> Para terminar la prueba la borramos.");
lista.borrar ();
lista.imprimir ();
}
}
Hola
Por lo que veo, tienes la clase ListaSecuencial, con la que tienes que trabajar, y que tiene los métodos siguientes:
Añadir(elemento) -> Añade al final de la lista
mover(indice) -> Mueve el apuntador a la posición indicada
insertar(elemento) -> Inserta un elemento en la posición de apuntador
eliminar() -> Elimina el elemento apuntado
ppio() -> Mueve el apuntador al principio de la lista, como mover(0)
Dentro() -> Devuelve True si el apuntador está dentro de la lista
siguiente() -> Mueve el apuntador al siguiente elemento
imprimir() -> Imprime la lista completa
obtener() -> Devuelve el elemento apuntado
borrar() -> Elimina la lista completa
Imagino que también habrá un método fin() que mueva el apuntador al último elemento de la lista.
Con esto es relativamente fácil crear las estructuras que indicas. La clave está sólo en mantener una serie de índices o apuntadores correctamente.
Te lo implemento en algo parecido a Java, ya no soy un experto en Java y puedo cometer errores. Para coger la idea te debe valer:
Pila FIFO: (cola)
La pila fifo no tiene complicación, ya que los elementos siempre se sacan comenzando por el principio (0), y se agregan al final.
class PilaFIFO {
Lista lista = new ListaSecuencial();
void Mete(String elemento) {
lista.añadir(elemento); // Agrego al final
}
String Saca() {
// Siempre saca el primer elemento (0), y luego lo borra, así que el elemento 1 pasa a ser el 0, es decir, el siguiente
lista.mover(0);
String ret=lista.obtener();
lista.eliminar(0);
return ret;
}
};
Lista LIFO: (pila)
En la lista LIFO, siempre se saca en orden inverso a la entrada, por lo que añado al principio, y también saco del principio
class ListaLIFO {
Lista lista=new ListaSecuencial();
void Mete(String elemento) {
lista.mover(0);
lista.insertar(elemento); // Agrego al principio
}
String Saca() {
lista.mover(0);
String ret=lista.obtener();
lista.eliminar(0);
return ret;
}
}
Como verás, la única diferencia es dónde añado.
Lista Circular:
En la lista circular, la única diferencia con una lista normal, es que al llegar al final se vuelve al principio:
class ListaCircular {
Lista Lista=new ListaSecuencial();
void Sgte(){
lista.sgte();
if(!lista.dentro())lista.mover(0);
}
}
El resto de los métodos son fáciles de implementar
Espero estarte ayudando
Saludos
Lo voy a intentar así, por lo menos ya como van las cosas, muchas gracias
Hola
Me alegro de serte de ayuda.
Si no quieres más aclaraciones por ahora, ¿puedes finalizar la pregunta, por favor? :-)
Saludos
Añade un comentario a esta respuesta
0
Respuesta de
Hola!
Usando la clase lista es muy fácil, estas estructuras solo difieren en la forma en introducen y sacan la información:
Cola: introduce el elemento por el final y lo saca por el principio.
Pila: introduce por el principio y saca por el principio
Lista circular: el ultimo elemento esta enlazado como el primero.
Lo único que tienes que hacer es crear una clase para cada una de ellas que tenga un objeto de tipo lista y métodos que te permitan operar con esta. Algo como
class pila
{
private List lista
pila()
{
lisa=new List(); //MUY IMPORTANTE!!!!
}
insertar(Object ob)
object extraer()
}
Con esto solo te queda insertar y extraer datos según la estructura que vayas a crear, para ello usa los siguientes métodos de la clase List:
-add(int index, Object element) : te permite añadir un elemento en la posicion indicada
boolean add(Object o) : te permite añadir un elemento al final de la lista.
get(int index) : te permite obtener el elemento indicado
remove(int index) : elimina el elemento indicado
Y la más importante: size() te devuelve el tamaño de la lista.
Siento la tardanza, espero que te llegue a tiempo.
Un saludo
Añade un comentario a esta respuesta
0
Respuesta de
Hola, perdona por la tardanza pero es que he estado fuera.
Para implementar esas estructuras solo tienes que hacer una clase que extienda una lista y redefinir los métodos para añadir y quitar elementos, si sabes como funciona una cola o una pila es muy sencillo.
Saludos.
Añade un comentario a esta respuesta
Añade tu respuesta
Haz clic para o
Escribe tu mensaje
¿No es la pregunta que estabas buscando?
Puedes explorar otras preguntas de los temas JavaDesarrollo web o hacer tu propia pregunta: