Archivo creado por la profesora Amparo

NO nos sirve para copiarlo i mean, todo esta diferente y ni siquiera muestra un laberitno decente
arielmerinos · Apr 15, 2020 · cef422f · cef422f
1 parent c8f011b
commit cef422f
Show file tree

Hide file tree

Showing 5 changed files with 833 additions and 0 deletions.
diff --git a/src/com/mx/edd/Cola.java b/src/com/mx/edd/Cola.java
@@ -0,0 +1,237 @@
+package com.mx.edd;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/**
+ * <p> Clase concreta para modelar la estructura de datos Cola</p>
+ * <p>Esta clase implementa una Cola genérica, es decir que es homogénea pero
+ * puede tener elementos de cualquier tipo.
+ * @author Kevin Ariel Merino Peña <arielmerino@ciencias.unam.mx>
+ * @version 1.0
+ * @param <T> Tipo que tienen los objetos que guarda esta cola.
+ */
+public class Cola<T> implements Coleccionable<T> {
+
+    private class Nodo {
+
+        /**
+         * El elemento del nodo.
+         */
+        public T elemento;
+        /**
+         * El siguiente nodo.
+         */
+        public Nodo siguiente;
+
+        /**
+         * Construye un nodo con un elemento.
+         *
+         * @param elemento el elemento del nodo.
+         */
+        public Nodo(T elemento) {
+            this.elemento = elemento;
+        }
+    }
+
+    private class IteradorCola implements Iterator<T> {
+        public Nodo siguiente;
+
+        public IteradorCola() {
+            siguiente = inicio;
+        }
+
+        /* Nos dice si hay un elemento siguiente. */
+        @Override
+        public boolean hasNext() {
+            return siguiente != null;
+        }
+
+        /* Nos da el elemento siguiente. */
+        @Override
+        public T next() {
+            T aux = siguiente.elemento;
+            siguiente = siguiente.siguiente;
+            return aux;
+        }
+
+        @Override
+        public void remove() {
+            throw new UnsupportedOperationException("No implementado");
+        }
+
+    }
+
+    /* Nodo inicial de la cola*/
+    private Nodo inicio;
+    /* Nodo final de la cola*/
+    private Nodo rabo;
+    /* Tamaño de la cola*/
+    private int elementos;
+
+
+    /**
+     * Constructor por omisión de la clase.
+     */
+    public Cola() {
+        //Aqui no hay que hacer nada, 
+        //ya que los valores por default nos sirven al crear un objeto.
+    }
+
+    /**
+     * Constructor que recibe un arreglo de elementos de tipo <code>T</code>.
+     * Crea una cola con los elementos del arreglo.
+     *
+     * @param elementos El arreglo que se recibe como parámetro.
+     */
+    public Cola(T[] elementos) {
+        for (T elem: elementos){
+            this.agrega(elem);
+        }
+    }
+
+
+    /**
+     * Constructor que recibe una colección de tipo {@link Coleccionable}
+     * de elementos de tipo <code>T</code> y los agrega a la nueva cola.
+     *
+     * @param elementos La colección de elementos a agregar.
+     */
+    public Cola(Coleccionable<T> elementos) {
+        for (T col : elementos){
+            this.agrega(col);
+        }
+    }
+
+    /**
+     * Agrega un elemento en el rabo de la Cola.
+     *
+     * @param elemento el elemento a agregar.
+     * @throws IllegalArgumentException si <code>elemento</code> es
+     *                                  <code>null</code>.
+     */
+    public void queue(T elemento) throws IllegalArgumentException {
+        if (elemento == null){
+            throw  new IllegalArgumentException("El elemento enviado es nulo");
+        }
+        Nodo nuevo = new Nodo(elemento);
+        if (esVacio()){
+            inicio = rabo = nuevo;
+        }else {
+            rabo.siguiente = nuevo;
+            rabo = nuevo;
+        }
+        elementos++;
+    }
+
+    /**
+     * Elimina el elemento del inicio de la Cola y lo regresa.
+     *
+     * @return el elemento en el inicio de la Cola.
+     * @throws NoSuchElementException si la cola es vacía
+     */
+    public T dequeue() throws NoSuchElementException {
+        if (esVacio()){
+            throw new NoSuchElementException("La estructura esta vacia");
+        }
+        T aux = inicio.elemento;
+        inicio = inicio.siguiente;
+        elementos--;
+        return aux;
+    }
+
+    /**
+     * Nos permite ver el elemento en el inicio de la Cola
+     *
+     * @return el elemento en un extremo de la estructura.
+     */
+    public T peek() {
+        return inicio.elemento;
+    }
+
+    /**
+     * Agrega un elemento a la Cola.
+     *
+     * @param elemento el elemento a agregar.
+     * @throws IllegalArgumentException si <code>elemento</code> es
+     *                                  <code>null</code>.
+     */
+    @Override
+    public void agrega(T elemento) throws IllegalArgumentException {
+        queue(elemento);
+    }
+
+    /**
+     * Nos dice si un elemento está contenido en la Cola.
+     *
+     * @param elemento el elemento que queremos verificar si está contenido en
+     *                 la Cola.
+     * @return <code>true</code> si el elemento está contenido en la Cola,
+     * <code>false</code> en otro caso.
+     */
+    @Override
+    public boolean contiene(T elemento) {
+        Iterator it = iterator();
+        while (it.hasNext()){
+            if (it.next().equals(elemento)){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Elimina un elemento de la Cola.
+     *
+     * @param elemento el elemento a eliminar.
+     * @throws NoSuchElementException si la cola es vacía
+     */
+    @Override
+    public void elimina(T elemento) throws NoSuchElementException {
+        dequeue();
+    }
+
+    /**
+     * Nos dice si la Cola está vacía.
+     *
+     * @return <tt>true</tt> si la Cola no tiene elementos,
+     * <tt>false</tt> en otro caso.
+     */
+    @Override
+    public boolean esVacio() {
+        return elementos == 0;
+    }
+
+    /**
+     * Regresa el número de elementos en la Cola.
+     *
+     * @return el número de elementos en la Cola.
+     */
+    @Override
+    public int getTamanio() {
+        return elementos;
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+        return new IteradorCola();
+    }
+
+    @Override
+    public String toString() {
+        String s = "[";
+        Nodo n = this.inicio;
+        while (n != null) {
+            if (n.siguiente == null) {
+                s += n.elemento;
+            } else {
+                s += n.elemento + ",";
+            }
+            n = n.siguiente;
+        }
+        s += "]";
+        return s;
+
+    }
+
+}
diff --git a/src/com/mx/edd/Coleccionable.java b/src/com/mx/edd/Coleccionable.java
@@ -0,0 +1,54 @@
+package com.mx.edd;
+
+import java.util.NoSuchElementException;
+
+/**
+ * <p>Interface para colecciones, con operaciones para agregar y eliminar
+ * elementos, y consultar si un elemento está contenido, así como para obtener
+ * el número de elementos en la colección. Además, Las colecciones son
+ * iterables.</p>
+ *
+ * <p>Las colecciones no aceptan a <code>null</code> como elemento; el
+ * comportamiento de las clases que implementen esta interfaz no está definido
+ * si <code>null</code> es pasado como parámetro a ninguno de sus métodos.</p>
+ * @param <T> Tipo genérico de los elementos que guarda.
+ */
+public interface Coleccionable<T> extends Iterable<T> {
+
+    /**
+     * Agrega un elemento a la colección.
+     * @param elemento el elemento a agregar.
+     * @throws IllegalArgumentException si <code>elemento</code> es
+     *         <code>null</code>.
+     */
+    public void agrega(T elemento) throws IllegalArgumentException;
+
+    /**
+     * Elimina un elemento de la colección.
+     * @throws NoSuchElementException si la colección es vacía.
+     * @param elemento el elemento a eliminar.
+     */
+    public void elimina(T elemento) throws NoSuchElementException;
+
+    /**
+     * Nos dice si un elemento está contenido en la colección.
+     * @param elemento el elemento que queremos verificar si está contenido en
+     *                 la colección.
+     * @return <code>true</code> si el elemento está contenido en la colección,
+     *         <code>false</code> en otro caso.
+     */
+    public boolean contiene(T elemento);
+
+    /**z
+     * Nos dice si el conjunto de elementos en la colección es vacío.
+     * @return <code>true</code> si el conjunto de elementos en la colección es
+     *         vacío, <code>false</code> en otro caso.
+     */
+    public boolean esVacio();
+
+    /**
+     * Regresa el número de elementos en la colección.
+     * @return el número de elementos en la colección.
+     */
+    public int getTamanio();
+}