Advertisement
jtentor

List.java [lista doble]

Oct 22nd, 2016
202
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.  
  2. public class List<E> {
  3.     /**
  4.      * Campos en la estructura interna o privada de la clase
  5.      */
  6.     private Node head;
  7.     private int count;
  8.     private Node tail;
  9.  
  10.     /**
  11.      * Getter para count
  12.      *
  13.      * @return cantidad de elementos en la lista
  14.      */
  15.     public int getCount() {
  16.         return this.count;
  17.     }
  18.  
  19.     /**
  20.      * Constructor por defecto
  21.      */
  22.     public List() {
  23.         this.head = null;
  24.         this.count = 0;
  25.         this.tail = null;
  26.     }
  27.  
  28.    
  29.     /**
  30.      * Agrega al principio
  31.      * Este código puede y debe mejorarse
  32.      *
  33.      * @param item elemento que se agrega a la lista
  34.      */
  35.     public void AddFirst(E item) {
  36.         // si esta vacía
  37.         if (this.count == 0) {
  38.             // se crea un nodo con el elemento a agregar
  39.             // el nuevo nodo es el primero y el último
  40.             this.head = this.tail = new Node(item, null, null);
  41.             // incrementa la cuenta de elementos
  42.             ++this.count;
  43.         }
  44.         else {
  45.             // se crea un nodo con el elemento a agregar
  46.             Node temp = new Node(item, null, null);
  47.             // el siguiente del nuevo nodo es el actual primero
  48.             temp.next = this.head;
  49.             // el anterior del actual primero es el nuevo nodo
  50.             this.head.prev = temp;
  51.             // el nuevo nodo se convierte en el primero
  52.             this.head = temp;
  53.             // incrementa la cuenta de elementos
  54.             ++this.count;
  55.         }
  56.     }
  57.  
  58.        
  59.     public void BetterAddFirst(E item) {
  60.         Node temp = new Node(item, this.head, null);
  61.         if (this.count == 0) {
  62.             this.tail = temp;
  63.         }
  64.         else {
  65.             this.head.prev = temp;
  66.         }
  67.         this.head = temp;
  68.         ++this.count;
  69.     }
  70.  
  71.  
  72.     /**
  73.      * Agrega al final
  74.      * Este código puede y debe mejorarse
  75.      *
  76.      * @param item elemento que se agrega a la lista
  77.      */
  78.     public void AddLast(E item) {
  79.         if (this.count == 0) {
  80.             // se crea un nodo con el elemento a agregar
  81.             // el nuevo nodo es el primero y el último
  82.             this.head = this.tail = new Node(item, null, null);
  83.             // incrementa la cuenta de elementos
  84.             ++this.count;
  85.         }
  86.         else {
  87.             // se crea un nodo con el elemento a agregar
  88.             Node temp = new Node(item, null, null);
  89.             // el anterior del nuevo nodo es el actual último
  90.             temp.prev = this.tail;
  91.             // el siguiente del actual último es el nuevo nodo
  92.             this.tail.next = temp;
  93.             // el nuevo es ahora el último
  94.             this.tail = temp;
  95.             // incrementa la cuenta de elementos
  96.             ++this.count;
  97.         }
  98.     }
  99.    
  100.  
  101.     public void BetterAddLast(E item) {
  102.         Node temp = new Node(item, null, this.tail);
  103.         if (this.count == 0) {
  104.             this.head = temp;
  105.         }
  106.         else {
  107.             this.tail.next = temp;
  108.         }
  109.         this.tail = temp;
  110.         ++this.count;
  111.     }
  112.    
  113.    
  114.  
  115.     /**
  116.      * Extrae y devuelve el primer elemento de la lista
  117.      *
  118.      * @return el elemento que se encuentra al principio de la lista
  119.      * @exception Lista vacía
  120.      */
  121.     public E RemoveFirst() {
  122.         if (this.count == 0) {
  123.             throw new RuntimeException("La lista está vacía...");
  124.         }
  125.  
  126.         // toma el elemento que está en el primer nodo
  127.         E item = this.head.item;
  128.         // avanza el primer nodo al siguiente
  129.         this.head = this.head.next;
  130.         // si no hay mas nodos
  131.         if (this.head == null) {
  132.             // vaciar la lista
  133.             this.tail = null;
  134.         }
  135.         else {
  136.             // suprimir la referencia al anterior en el actual primero
  137.             this.head.prev = null;
  138.         }
  139.         // decrementa la cuenta de elementos
  140.         --this.count;
  141.         // regresar el elemento
  142.         return item;
  143.     }
  144.    
  145.    
  146.    
  147.     /**
  148.      * Extrae y devuelve el último elemento de la lista
  149.      *
  150.      * @return el elemento que se encuentra al final de la lista
  151.      * @exception Lista vacía
  152.      */
  153.     public E RemoveLast() {
  154.         if (this.count == 0) {
  155.             throw new RuntimeException("La lista está vacía...");
  156.         }
  157.  
  158.         E item = this.tail.item;
  159.  
  160.         // si es el único nodo
  161.         if (this.head.next == null) {
  162.             // vacía la lista
  163.             this.head = this.tail = null;
  164.         } else {
  165.             // accede al penúltimo nodo que ahora será el último
  166.             this.tail = this.tail.prev;
  167.             // anula la referencia al siguiente nodo
  168.             this.tail.next = null;
  169.         }
  170.         // decrementa la cuenta de elementos
  171.         --this.count;
  172.         // regresa el elemento
  173.         return item;
  174.        
  175.     }
  176.    
  177.    
  178.    
  179.    
  180.     /**
  181.      * Muestra en la salida estándar todos los elementos de la lista
  182.      *
  183.      * Para evitar código como este, se aconseja implementar interfaces
  184.      * que permitan recorrer la lista, como ser Iterable e Iterator
  185.      *  
  186.      */
  187.     public void Mostrar() {
  188.         for (Node skip = this.head; skip != null; skip = skip.next) {
  189.             System.out.printf("%s ", skip.toString());
  190.         }
  191.     }
  192.    
  193.    
  194.    
  195.    
  196.    
  197.    
  198.    
  199.    
  200.    
  201.    
  202.    
  203.    
  204.    
  205.    
  206.    
  207.  
  208.    
  209.     /**
  210.      * Clase privada para los nodos de la lista
  211.      */
  212.     private class Node {
  213.         /**
  214.          * Campos en la estructura interna o privada de la clase
  215.          */
  216.         public E item;
  217.         public Node next;
  218.         public Node prev;
  219.        
  220.         /**
  221.          * Constructor por defecto
  222.          */
  223.         public Node() {
  224.             this(null, null, null);
  225.         }
  226.  
  227.         /**
  228.          * Constructor especializado
  229.          *
  230.          * @param item elemento a mantener en el nodo
  231.          */
  232.         public Node(E item) {
  233.             this(item, null, null);
  234.         }
  235.  
  236.         /**
  237.          * Constructor especializado
  238.          *
  239.          * @param item elemento a mantener en el nodo
  240.          * @param next referencia al siguiente nodo
  241.          */
  242.         public Node(E item, Node next) {
  243.             this(item, next, null);
  244.         }
  245.        
  246.         /**
  247.          * Constructor especializado
  248.          *
  249.          * @param item elemento a mantener en el nodo
  250.          * @param next referencia al siguiente nodo
  251.          * @param prev referencia al nodo anterior
  252.          */
  253.         public Node(E item, Node next, Node prev) {
  254.             this.item = item;
  255.             this.next = next;
  256.             this.prev = prev;
  257.         }
  258.  
  259.         /**
  260.          * Devuelve una cadena de texto que representa el contenido
  261.          * del elemento que está en el nodo
  262.          *
  263.          * Esto es un ejemplo de "delegación"
  264.          */
  265.         public String toString() {
  266.             return this.item.toString();
  267.         }
  268.     }
  269. }
Advertisement
RAW Paste Data Copied
Advertisement