E6: el método toArray de LEG

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;
}
}