Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » Invertir elementos de una cola

Java - Invertir elementos de una cola

Volver
Nuevo Tema
<<>>
 
Vista:
Imágen de perfil de Lucas
Val: 68
Ha disminuido su posición en 3 puestos en Java (en relación al último mes)
Gráfica de Java

Invertir elementos de una cola

Publicado por Lucas (23 intervenciones) el 11/11/2020 17:00:35
Buenas tardes, Alguien sabe como crear un método en Java para invertir el orden de los elementos almacenados en una cola?

Primero compruebo si la cola está vacía, pero después como puedo invertir los elementos?

Gracias!

Clase ColaInversa

1
2
3
4
5
6
7
8
9
10
11
12
13
public class ColaInversa {
	public static void invertir(Cola cola) {
 
		if (cola.esVacia()) {
			System.out.println("No hay elementos en la cola");
 
		}
 
 
 
		return ;
	}
}


Clase PruebaColaInversa

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class PruebaColaInversa {
 
	public static void main(String[] args) {
 
		Cola cola = new ColaVector(6);
		cola.insertar("A");
		cola.insertar("B");
		cola.insertar("C");
		cola.insertar("D");
 
		System.out.println(cola);
		ColaInversa.invertir(cola);
		System.out.println(cola);
 
	}
}
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

Invertir elementos de una cola

Publicado por Tom (1831 intervenciones) el 12/11/2020 09:24:56
¿ Qué es ColaVector ?
¿ Por qué necesitas la clase ColaInversa ?
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Lucas
Val: 68
Ha disminuido su posición en 3 puestos en Java (en relación al último mes)
Gráfica de Java

Invertir elementos de una cola

Publicado por Lucas (23 intervenciones) el 13/11/2020 10:58:48
Buenos días,

La estructura del proyecto es la siguiente: tres clases: Cola, ColaVector y ColaEnlazada. Y en src tengo una clase para desarrollar el ejercicio que es ColaInversa.

Después tengo que realizar las pruebas en PruebaColaInversa

Saludos!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Invertir elementos de una cola

Publicado por Kabuto (1381 intervenciones) el 13/11/2020 11:31:35
Tendríamos que ver el código de todas las clases que intervienen en el programa para ver que estructuras de datos se están usando.

Pero bueno, quizás este ejemplo que pongo a continuación te sirva de inspiración.

Es un programa con un método que recibe un vector y retorna una copia invertida.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public class InvertirArray {
 
	public static void main(String[] args) {
 
		int[] vectorOrigen = {1, 2, 3, 4, 5};
 
		int[] vectorInvertido = invertirVector(vectorOrigen);
 
		System.out.println("Vector original:");
		System.out.println(Arrays.toString(vectorOrigen));
 
		System.out.println("\nVector invertido:");
		System.out.println(Arrays.toString(vectorInvertido));
 
	}
 
	/**
	 * Método que recibe un vector de enteros y retorna una copia invertida
	 * @param vector Vector original
	 * @return Copia inverida del vector origen
	 */
	private static int[] invertirVector(int[] vector) {
 
		//Creamos nuevo vector con la misma longitud que el original
		int[] invertido = new int[vector.length];
 
		/*
		 * Usaremos dos indices.
		 * Uno recorrerá el vector origen desde atrás hacia adelante
		 * El otro recorre el invertido desde delante hacia atrás.
		 * Así los elementos que nos da el primer indice, los colocamos
		 * donde marca el segundo
		 */
		int adelante = 0;
		int atras = vector.length - 1;
 
		for ( ;adelante < vector.length; adelante++) {
			invertido[adelante] = vector[atras];
			atras--; //Decrementamos el indice que va hacia atrás
		}
 
		return invertido;
	}
 
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Lucas
Val: 68
Ha disminuido su posición en 3 puestos en Java (en relación al último mes)
Gráfica de Java

Invertir elementos de una cola

Publicado por Lucas (23 intervenciones) el 13/11/2020 11:49:06
Estos son los códigos de todas las clases:

Clase Cola
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package colas;
 
import excepciones.DesbordamientoInferior;
 
public interface Cola {
	/** Inserta un elemento al final de la cola. **/
	public void insertar(Object elemento);
 
	/** Devuelve el elemento que lleva más tiempo en la cola. **/
	public Object primero() throws DesbordamientoInferior;
 
	/** Elimina el elemento que lleva más tiempo en la cola. **/
	public void quitarPrimero() throws DesbordamientoInferior;
 
	/** Determina si la cola está vacía **/
	public boolean esVacia();
}


Clase ColaVector
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package colas;
import excepciones.DesbordamientoInferior;
 
public class ColaVector implements Cola{
 
	private Object datos[];
	/** Posición del primer elemento de la cola. **/
	int inicio;
	/** Posición del último elemento de la cola. **/
	int fin;
	/** Número de elementos que contiene la cola. **/
	private int numElementos;
 
	public ColaVector(int tam){
		datos = new Object[tam];
		inicio=0;
		fin=-1;
		numElementos=0;
	}
	/** Determina si la cola está vacía **/
	public boolean esVacia() {
		return (numElementos==0);
	}
	/** Inserta un elemento al final de la cola. * */
	public void insertar(Object elemento) {
	// Se comprueba si está llena la cola
	if (numElementos == datos.length) {
	System .out.println( "La cola está llena y no se puede realizar la operación de insertar" );
	}
	else {
	// Se incrementan las variables correspondientes y se
	// introduce un nuevo elemento.
	fin++;
	if (fin == datos.length) {
	fin = 0;
	}
	datos[fin] = elemento;
	numElementos++;
	}
	}
	/** Devuelve el elemento que lleva más tiempo en la cola. **/
	public Object primero() throws DesbordamientoInferior {
		// Comprueba si la cola está vacía
		if(esVacia()){
			throw new DesbordamientoInferior("La cola está vacía y no hay un primer elemento");
		}
		// Devuelve el primer elemento
		return datos[inicio];
	}
	/** Elimina el elemento que lleva más tiempo en la cola. **/
	public void quitarPrimero() throws DesbordamientoInferior {
		// Comprueba si la cola está vacía
		if(esVacia()){
			throw new DesbordamientoInferior("La cola está vacía y no hay un primer elemento");
		}
		// Actualiza las variables inicio y numElementos
		inicio++;
		if(inicio==datos.length){
			inicio= 0;
		}
		numElementos--;
	}
}

Clase ColaEnlazada
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package colas;
 
import nodos.Nodo;
import excepciones.DesbordamientoInferior;
 
public class ColaEnlazada implements Cola {
 
 
	public ColaEnlazada() {
		inicio = null;
		fin = null;
	}
 
	/** Determina si la cola está vacía. **/
	public boolean esVacia() {
		return (inicio == null);
	}
 
	/** Inserta un elemento al final de la cola. **/
	public void insertar(Object elemento) {
		// Se crea un nuevo nodo con el elemento y que el siguiente enlace apunte a nulo
		Nodo nuevo = new Nodo(elemento);
		nuevo.setEnlace(null);
		// Si está vacía, se apunta por inicio y fin
		if (esVacia()) {
			inicio = nuevo;
			fin = nuevo;
		} else {
			fin.setEnlace(nuevo);
			fin = nuevo;
		}
	}
 
	/** Devuelve el elemento que lleva más tiempo en la cola. **/
	public Object primero() throws DesbordamientoInferior {
		// Comprueba si la cola está vacía
		if (esVacia()) {
			throw new DesbordamientoInferior("La cola está vacía y no hay un primer elemento");
		}
		// Devuelve el primer elemento
		return inicio.getElemento();
	}
 
	/** Elimina el elemento que lleva más tiempo en la cola. **/
	public void quitarPrimero() throws DesbordamientoInferior {
		// Comprueba si la cola está vacía
		if (esVacia()) {
			throw new DesbordamientoInferior("La cola está vacía y no hay un primer elemento");
		}
		/*
		 * Inicio se establece al segundo elemento y el recolector de basura borra el
		 * primero automáticamente al dejar de ser referenciado
		 */
		inicio = inicio.getEnlace();
		/*
		 * Si solo había un elemento, la referencia fin deberá pasar a nulo dado que la
		 * cola está vacía
		 */
		if (inicio == null) {
			fin = null;
		}
	}
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Lucas
Val: 68
Ha disminuido su posición en 3 puestos en Java (en relación al último mes)
Gráfica de Java

Invertir elementos de una cola

Publicado por Lucas (23 intervenciones) el 13/11/2020 12:24:54
Hola de nuevo,
He modificado el código pero no me invierte los elementos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int[] invertir = new int[ColaVector.numElementos];
 
/*
 * Usaremos dos indices.
 * Uno recorrerá el vector origen desde atrás hacia adelante
 * El otro recorre el invertido desde delante hacia atrás.
 * Así los elementos que nos da el primer indice, los colocamos
 * donde marca el segundo
 */
int adelante = 0;
int atras = ColaVector.numElementos - 1;
 
for ( ;adelante < ColaVector.numElementos; adelante++) {
    invertir[adelante] = invertir[atras];
    atras--; //Decrementamos el indice que va hacia atrás
}
 
return invertir;

En la prueba siguiente:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void main(String[] args) {
 
		Cola cola = new ColaVector(6);
		cola.insertar("A");
		cola.insertar("B");
		cola.insertar("C");
		cola.insertar("D");
 
		System.out.println(cola);
		Ejercicio2.invertir(cola);
		System.out.println(cola);
 
	}
}

El resultado es este:
ColaVector[A, B, C, D]
ColaVector[A, B, C, D]
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Invertir elementos de una cola

Publicado por Kabuto (1381 intervenciones) el 15/11/2020 01:02:17
Hola.

La adaptación que has hecho de mi código no es correcta.
Para empezar, el vector que yo puse lo hice de int por poner un ejemplo. En tu caso, tus Colas trabajan con clase Object, no int.

Además, si te fijas, en ningún momento modificas los objetos de la cola. Solo trabajas con el vector de int llamado "invertir", que en ningún momento tiene información procedente de la Cola.

1
2
3
4
for ( ;adelante < ColaVector.numElementos; adelante++) {
    invertir[adelante] = invertir[atras];
    atras--; //Decrementamos el indice que va hacia atrás
}


De todos modos, viendo como funciona tu Cola, el ejemplo que puse no se puede aplicar de forma tan directa.
Pero en cualquier caso, la lógica a seguir es muy parecida: hacer una copia con un indice y/o bucle que va hacia adelante y devolver los elementos copiados con un indice y/o bucle que va hacia atrás.


Bueno, lo primero para poder hacer una copia, es saber cual es el tamaño de la cola.
En tu código parece que has optado por hacer public el atributo numElementos

Usar este atributo es arriesgado. Si como has puesto en el ejemplo, declaramos una Cola de 6 elementos pero solo insertamos 4..., si queremos hacer una copia, esta copia solo tendrá 4 elementos.
Luego, tras copiar y "eliminar" (entrecomillo porque en el fondo la cola es un array, y los arrays son inmutables, no se puede añadir/eliminar elementos) sus datos para luego insertarlos de nuevo en orden inverso...no sale bien la cosa, debido a que la copia es de 4 elementos pero el original es de 6.
Ya lo he probado, y no sale bien. Quizás añadiendo más código extra se pudiera solucionar..., no se...

En mi caso, he preferido añadir un método que me retorne el tamaño del vector, y no de cuántos elementos tiene la Cola.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public interface Cola {
 
	public int getLongitudCola();
 
	/** Inserta un elemento al final de la cola. **/
	public void insertar(Object elemento);
 
	/** Devuelve el elemento que lleva más tiempo en la cola. **/
	public Object primero();
 
	/** Elimina el elemento que lleva más tiempo en la cola. **/
	public void quitarPrimero();
 
	/** Determina si la cola está vacía **/
	public boolean esVacia();
 
}

Además, añado el método toString() para poder mostrar rápidamente todo el vector:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class ColaVector implements Cola{
 
	private Object datos[];
	/** Posición del primer elemento de la cola. **/
	int inicio;
	/** Posición del último elemento de la cola. **/
	int fin;
	/** Número de elementos que contiene la cola. **/
	private int numElementos;
 
	public ColaVector(int tam){
		datos = new Object[tam];
		inicio=0;
		fin=-1;
		numElementos=0;
	}
 
	public int getLongitudCola() {
		return datos.length;
	}
 
	public String toString() {
		return Arrays.toString(datos);
	}
 
	/** Determina si la cola está vacía **/
	public boolean esVac........
	...........................................


Entonces, en ColaInversa, lo que hago es:

- Crear un array de Object[] con la misma longitud que el array de la Cola que vamos a invertir
- Copia cada elementos de la Cola, y lo elimino de la misma
- Finalizada la copia, con un bucle que va a la inversa, vuelvo a insertar los elementos en la Cola.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class ColaInversa {
 
	public static void invertir(Cola cola) {
 
		if (cola.esVacia())
			System.out.println("No hay elementos en la cola");
		else{
			//Creamos array con la misma longitud
			Object[] copia = new Object[cola.getLongitudCola()];
 
			//Hacemos copia de cada elemento, y una vez copiada, eliminamos de la Cola
			for (int i = 0; i < copia.length; i++) {
				copia[i] = cola.primero();
				cola.quitarPrimero();
			}
			//Elementos copiados y cola vacía
 
			//Volvemos a insertarlos, pero en orden inverso
 
			for (int i = copia.length - 1; i >= 0; i--)
				cola.insertar(copia[i]);
 
			//Listo. Cola invertida
		}
 
	}
}

Si lo ponemos a prueba con una Cola de 4 elementos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class PruebaColaInversa {
 
	public static void main(String[] args) {
 
		ColaVector cola = new ColaVector(4);
		cola.insertar("A");
		cola.insertar("B");
		cola.insertar("C");
		cola.insertar("D");
 
		System.out.println(cola);
		ColaInversa.invertir(cola);
		System.out.println(cola);
 
	}
}

Funciona bien.
1
2
[A, B, C, D]
[D, C, B, A]

Si la Cola es de 6 pero solo 4 elementos insertados, también funciona, pero tal y como he puesto el método toString(), se muestran los objetos null que no han recibido elementos:
1
2
[A, B, C, D, null, null]
[D, C, B, A, null, null]

Queda un poco feo, tal vez habría que hacer reescribir el método toString() y hacerlo un poco más elaborado para que no se muestren los elementos null.

Pero bueno, la inversión funciona.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Lucas
Val: 68
Ha disminuido su posición en 3 puestos en Java (en relación al último mes)
Gráfica de Java

Invertir elementos de una cola

Publicado por Lucas (23 intervenciones) el 15/11/2020 18:46:21
Buenas, gracias por todo el trabajo.
A mi no me funciona, me da el siguiente error:

[A, B, C, D, null, null]
Exception in thread "main" excepciones.DesbordamientoInferior: La cola está vacía y no hay un primer elemento
at colas.ColaVector.primero(ColaVector.java:56)
at aa1.apartado2.ejercicio2.Ejercicio2.invertir(Ejercicio2.java:20)
at aa1.apartado2.ejercicio2.pruebas.Prueba1.main(Prueba1.java:18)
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Invertir elementos de una cola

Publicado por Kabuto (1381 intervenciones) el 15/11/2020 21:44:20
Vale.
A mi eso no me sale porque no puse ningún throw.
En tu código se está imponiendo una excepción que se "lanza" cuando se accede a un elemento null.
Es decir, si declaras una Cola de 6 elementos, pero solo insertas 4, al acceder al quinto elemento encontramos un valor null, porque estamos "fuera" de la Cola.

Cuando esto ocurre, en tu código lanzas la excepción DesbordamientoInferior y el programa se detiene.
Yo como no lanzo nada, pues no pasa nada y el programa sigue adelante.

Puedes usar try catch para capturar esa excepción y evitar que el programa se detenga.
Ya decides si hacer algo o no cuando la capturas.
Puedes dejar el catch vacío, es decir, no hacer nada... y el programa seguirá adelante
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar