Otras implementaciones de una LEG E6: el método toArray de LEG<E> public void toArray(E [] a) { NodoLEG<E> aux; int i; for ( aux=primero, i=0; aux!=null; aux=aux.siguiente, i++) a[i] = aux.dato; } public Object [] toArray() { Object copia[]= new Object[talla]; NodoLEG<E> aux; int i; for ( aux=primero, i=0; aux!=null; aux=aux.siguiente, i++) copia[i] = aux.dato; return copia; } public E [] toArray(E [] a) { NodoLEG<E> aux; int i; for ( aux=primero, i=0; aux!=null; aux=aux.siguiente, i++) a[i] = aux.dato; return a; } LEG con Referencias al primer y último Nodo La clase LEGConUltimo<E> LEG Circular La clase LEGCircular<E> Lista Doblemente Enlazada La clase NodoLEGDE<E> La clase LEGDE<E> La clase LEGConUltimo<E> LEG con Enlaces al primero y último Nodo insertarEnFin de una LEG tiene un coste lineal con su talla ¿ Se puede mejorar ese coste ? ¿ Cómo ? 1. 2. SÍ, hasta reducirlo a una constante Añadir a LEG<E> una nueva Referencia al último Nodo de la LEG primero NodoLEG1 NodoLEG1 NodoLEG2 NodoLEG2 .... package lineales; import excepciones.*; public class LEGConUltimo<E> { protected NodoLEG<E> primero, ultimo; protected int talla; public LEGConUltimo () {...} public int talla() { ...} public void insertar(E x) {...} // Se proponen como Ejercicios: public void insertarEnFin(E x) {...} // E7 public E borrar(E aBorrar) throws ElementoNoEncontrado{...} // E8 ... NodoLEGTalla NodoLEGTalla ultimo } Una alternativa a LEGConUltimo: LEGCircular<E> Los métodos de LEGConUltimo<E> public LEGConUltimo() { primero = null; Una LEG Circular es una LEG con Referencias al primero y ultimo Nodo en la que el siguiente al ultimo Nodo es el primero ultimo = null; talla = 0; } ultimo public void insertar(E x){ primero = new NodoLEG<E>(x, primero); NodoLista1 NodoLista1 primero NodoLista2 NodoLista2 if ( ultimo == null ) ultimo = primero; NodoListaTalla NodoListaTalla .... talla++; } Los métodos de LEGCircular<E> La clase LEGCircular<E> package lineales; public String toString(){ import excepciones.*; String res = ""; public class LEGCircular<E> { if ( ultimo != null ) { for (NodoLEG<E> aux= ultimo.siguiente ; aux != ultimo; aux =aux.siguiente) protected NodoLEG<E> ultimo; res += aux.dato.toString()+"\n"; protected int talla; public LEGCircular() { ... } ultimo = null; talla = 0; } res += ultimo.dato.toString()+"\n"; } return res; public int talla() { ...} public String toString() { ...} } // Se proponen como Ejercicios: public void insertar(E x) { ...} // E9 public void insertarEnFin(E x) { ...} // E10 ... } ultimo NodoLista1 NodoLista1 NodoLista2 NodoLista2 .... NodoListaTalla NodoListaTalla La clase de los Nodos de una Lista Doblemente Enlazada: NodoLDEG<E> Lista Doblemente Enlazada friendly package lineales; Una Lista Doblemente Enlazada es una LEG en la que cada Nodo tiene información tanto sobre su Nodo siguiente como su Nodo anterior. Permite así, 1. acceso en tiempo constante al Nodo anterior y al siguiente a uno dado 2. recorrer y buscar Ascendente o Descendentemente NodoLDEG1 NodoLDEG1 primero NodoLDEG2 NodoLDEG2 .... class NodoLDEG<E>{ E dato; NodoLDEG<E> siguiente, anterior; NodoLDEG(E dato) { this(dato, null , null); } NodoLDEG (E dato, NodoLDEG<E> s, NodoLDEG<E> a) { this.dato = dato; this.siguiente = s; this.anterior = a; } NodoLDEGTalla NodoLDEGTalla } Los métodos de LDEG<E> La clase LDEG<E> package lineales; public void insertar(E x){ import excepciones.*; NodoLDEG<E> nuevo = new NodoLDEG<E>(x, primero, null); public class LDEG<E>{ if ( primero != null ) primero.anterior = nuevo; protected NodoLDEG<E> primero; primero = nuevo; protected int talla; public LDEG() { ... } talla++; primero = null; talla = 0; } public int talla() { ...} } public void insertar(E x) {...} // Se proponen como Ejercicios: public E borrar(E aBorrar) throws ElementoNoEncontrado{...} // E11 primero NodoListaDE1 NodoListaDE1 public void insertarEnFin(E x) {...} // E12 ... } x x null null null null NodoListaDE2 NodoListaDE2 .... NodoListaDETalla NodoListaDETalla E13: Ejercicio Escribir un método toString() de LDEG<E> que obtenga una representación textual de los Nodos de la Lista en orden descendente, del último al primero E14: Ejercicio ¿Es conveniente que LEGOrdenada<…> sobrescriba también el método borrar de LEG<E>? En caso afirmativo, indíquese por qué y realícense las modificaciones oportunas. LEG Ordenada package lineales; public class LEGOrdenada<E extends Comparable<E>> extends LEG<E> { public void insertar(E x){ NodoLEG<E> nuevo = new NodoLEG<E>(x); NodoLEG<E> ant = null, aux = primero; while ( aux != null && (aux.dato).compareTo(x) < 0 ) { ant = aux; aux = aux.siguiente; } nuevo.siguiente = aux; if (ant != null) ant.siguiente = nuevo; else primero = nuevo; } }