Código para Bicolas genéricas usando Vectores:
|
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 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 |
/** * Proyecto: 9x03-Bicola - Vector * Fichero: Bicola.java * Fecha: 17/05/2012 * * Licencia (CC) BY-NC-SA: giltesa.com * * http://docs.oracle.com/javase/7/docs/api/java/util/Vector.html * http://mundogeek.net/archivos/2009/03/11/generics-en-java/ */ import java.util.Vector; public class Bicola<G> { // PROPIEDADES: private Vector<Nodo<G>> vNodos; // CONSTRUCTOR: // Se instancia un Vector de Nodos Genericos. (Del tipo con el que instanciamos la Bicola). public Bicola() { vNodos = new Vector<Nodo<G>>(5, 2); } // METODOS: // Se devuelve el numero de elementos usados en el Vector. public int getNumDeNodos() { return vNodos.size(); } // Se añade un Nodo a la izquierda y se desplazan los demas una posicion a la derecha en el indice. public void addNodoIzquierda( G dato ) { vNodos.add(0, new Nodo<G>(dato)); } // Se añade al final del Vector un nuevo Nodo: public void addNodoDerecha( G dato ) { vNodos.addElement(new Nodo<G>(dato)); } // Se copia el primer elemento en temp, despues se elimina del Vector. public G getNodoIzquierda() { G temp = vNodos.firstElement().getDatoNodo(); vNodos.removeElementAt(0); return temp; } // Se copia el ultimo elemento en temp, despues se elimina del Vector. public G getNodoDerecha() { G temp = vNodos.lastElement().getDatoNodo(); vNodos.removeElementAt(vNodos.size() - 1); return temp; } // Se concatenan todos los elementos del Vector en cadena y luego se devuelve. public String toString() { String cadena = ""; for( int i = 0; i < vNodos.size(); i++ ) cadena += vNodos.get(i).getDatoNodo() + ", "; return cadena; } } |
Código para Bicolas genéricas usando Referencias:
|
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 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 |
/** * Proyecto: 9x03-Bicola - Referencias * Fichero: Bicola.java * Fecha: 17/05/2012 * * Licencia (CC) BY-NC-SA: giltesa.com */ public class Bicola<G> { // PROPIEDADES: private int numDeNodos; private Nodo<G> primerNodo; private Nodo<G> ultimoNodo; // METODOS: public int getNumDeNodos() { return numDeNodos; } // Añade un nuevo Nodo a la izquierda modificando las referencias de las propiedades. public void addDatoIzquierda( G dato ) { Nodo<G> temp = new Nodo<G>(dato); if( primerNodo == null ) { primerNodo = temp; ultimoNodo = temp; } else { temp.setNodoSiguiente(primerNodo); primerNodo.setNodoAnterior(temp); primerNodo = temp; } numDeNodos++; } // Añade un nuevo Nodo a la derecha modificando las referencias de las propiedades. public void addDatoDerecha( G dato ) { Nodo<G> temp = new Nodo<G>(dato); if( ultimoNodo == null ) { primerNodo = temp; ultimoNodo = temp; } else { temp.setNodoAnterior(ultimoNodo); ultimoNodo.setNodoSiguiente(temp); ultimoNodo = temp; } numDeNodos++; } // Extrae el primer dato y cambia las referenciaas de las propiedades. public G getDatoIzquierda() { G temp = primerNodo.getDatoNodo(); if( primerNodo == ultimoNodo ) // Solo hay un nodo y se acaba de extraer quedando ahora 0. { primerNodo = null; ultimoNodo = null; } else { primerNodo = primerNodo.getNodoSiguiente(); primerNodo.setNodoAnterior(null); } numDeNodos--; return temp; } // Extrae el ultimo dato y cambia las referenciaas de las propiedades. public G getDatoDerecha() { G temp = ultimoNodo.getDatoNodo(); if( primerNodo == ultimoNodo ) { primerNodo = null; ultimoNodo = null; } else { ultimoNodo = ultimoNodo.getNodoAnterior(); ultimoNodo.setNodoSiguiente(null); } numDeNodos--; return temp; } // Concatena todos los elementos de la Bicola por referencias y lo retorna. public String toString() { String cadena = ""; Nodo<G> posicion = primerNodo; while(posicion != null) { cadena += posicion.getDatoNodo() + ", "; posicion = posicion.getNodoSiguiente(); } return cadena; } } |
QUE CHUCHA ES G
Es la clase que le pases cuando instancias la bicola.