Curso de Java: Resolución del ejercicio de equipos y árbitros

Escrito por Adrián Crespo
Java
2

Volvemos otro lunes más con el curso de Java que estamos realizando en RedesZone.net.

En la anterior entrega, os dejamos un ejercicio propuesto para ver las diferencias entre una pila y una cola de datos a la hora de llevar acabo la implementación.

Hoy, por lo tanto os daremos la solución del ejercicio de forma detallada y además, os emplazaremos para la siguiente estructura de datos, que nos ocupará las próximas entregas del curso, los mapas.

Pero en primer lugar, vamos con la solución del ejercicio.

Si recordáis bien, os decíamos que había que hacer una pila para los árbitros y una cola para meter los equipos. Como bien sabéis, la pila de los árbitros deberá responder a la siguiente interfaz:


import java.util.*;
/**
 * Interfaz que representa una pila abstracta
 */

public interface Pila<E>
{
 void apila(E e);
 E desapila() throws NoSuchElementException;
 void hazNula();
 E cima() throws NoSuchElementException;
 boolean estaVacia();
 int tamano();
}

Por lo tanto, una posible implementación de la pila es la siguiente:


import java.util.*;
public class PilaArbitros<E> implements Pila<String>
{
 LinkedList<String> pilaArbitros= new LinkedList<String>();

@Override
 public void apila(String arbitro)
 {
 pilaArbitros.add(arbitro);

 }

@Override
 public String desapila() throws NoSuchElementException
 {
 String a= pilaArbitros.get(pilaArbitros.size()-1);
 pilaArbitros.remove(pilaArbitros.size()-1);

 return a;
 }

@Override
 public void hazNula()
 {
 pilaArbitros.clear();
 }

@Override
 public String cima() throws NoSuchElementException {

 return pilaArbitros.get(pilaArbitros.size());
 }

@Override
 public boolean estaVacia()
 {

 return pilaArbitros.isEmpty();
 }

@Override
 public int tamano() {

 return pilaArbitros.size();
 }

}

Respondiendo a la interfaz de las pilas, como bien se sabe, el último en ser insertado es el primero en extraerse. Por lo tanto debemos recurrir a size()-1 para acceder de forma directa al último elemento, ya que hemos empleado una LinkedList.

Ahora vamos a implementar la cola de los equipos. Al recurrir a la clase Queue, sólo tenemos que utilizar los métodos que nos proporciona Java:


import java.util.*;

public class ColaEquipos
{
 private Queue<String> colaEquipos = new LinkedList<String>();

 public void InsertaAlPrincipio(String equipo)
 {
 colaEquipos.add(equipo);
 }

 public String extraeElPrimero()
 {
 return colaEquipos.poll();
 }

 public void muestraEquiposEncolados()
 {
 for(String equipo: colaEquipos)
 {
 System.out.println("Equipo: "+equipo);
 }
 }

}

Ya tenemos las dos clases principales, ahora vamos a hacer un ejemplo de programa de prueba sencillo:


public class ProgramaPrincipal
{
 public static void main (String[]args)
 {
 PilaArbitros pila = new PilaArbitros();
 ColaEquipos cola = new ColaEquipos();

 //Vamos a insertar equipos
 cola.InsertaAlPrincipio("Real Madrid");
 cola.InsertaAlPrincipio("Barcelona");
 cola.InsertaAlPrincipio("Murcia");
 cola.InsertaAlPrincipio("Racing");
 cola.InsertaAlPrincipio("Real Sociedad");
 cola.InsertaAlPrincipio("Sevilla");
 cola.InsertaAlPrincipio("Deportivo");
 cola.InsertaAlPrincipio("Atlético de Madrid");
 cola.InsertaAlPrincipio("Villareal");

 //Insertamos arbitros
 pila.apila("Iturralde");
 pila.apila("Paradas Romero");
 pila.apila("Menjuto González");
 pila.apila("Álvarez Izquierda");
 pila.apila("Fernández Borbalan");

 String equipoA;
 String equipoB;
 String arbitro;

 int i=0;

 while(i<4)
 {
 equipoA=cola.extraeElPrimero();
 equipoB=cola.extraeElPrimero();
 arbitro=pila.desapila();

 System.out.println("Enfrentamiento número "+(i+1)+"nn");
 System.out.println(equipoA+" vs "+equipoB+", dirigido por "+arbitro+"nnn");

 i++;
 }
 }

}

Como podéis observar si lo ejecutáis, los equipos se extraen en el orden insertado. Sin embargo los árbitros se extraen por la cabeza, extrayéndose siempre, el que más tarde se ha insertado.

Ahora vamos a comenzar a introducirnos a los mapas de datos en Java.

Un mapa es una función de unos elementos de un tipo clave, en otros elementos de un tipo destino.

Es una generalización del array:

  • El array es una tabla de valores en la que el índice es un entero.
  • El mapa es una tabla de valores en la que el índice es de cualquier tipo (la clave).

El mapa no puede tener claves repetidas:

  • Pero dos claves pueden referirse al mismo valor.

Las claves deben ser objetos inmutables (no pueden modificarse NUNCA a lo largo de la ejecución del programa).

De momento, vamos a dejarlo en este punto. Para la siguiente entrega, veremos los métodos que caracterizan los mapas en Java, y lo acompañaremos con un ejemplo para que os sirva de guía para los futuros ejercicios que os podamos proponer.


Noticias relacionadas

Comentarios


2 comentarios
  1. Domingo A. 30 Nov, 12 12:26

    Hola, buen tuto!!!

    Estoy siguiendo todos los tutoriales para recodar mis conocimientos de Java y he encontrado una errata en la función “cima” de la clase Pila. Se debería devolver el ítem de la pila situado en la posición size()-1 en lugar de size() ya que de lo contrario se produce una excepción “índice fuera de rango”.

    Debería quedar:

    @Override
    public String cima() throws NoSuchElementException {
    return pilaArbitros.get(pilaArbitros.size());
    }

    Responder
    0
  2. Domingo A. 30 Nov, 12 12:28

    Perdón, no lo he modificado. Debería quedar:

    Debería quedar:

    @Override
    public String cima() throws NoSuchElementException {
    return pilaArbitros.get(pilaArbitros.size()-1);
    }

    Saludos

    Responder
    0