APELLIDOS Y NOMBRES : JIMENEZ FLORES VEIMAR RAMIRO CARRERA: ING.

SISTEMAS
DIAGRAMA DE CLASES

< Interface>
ListaSE<T>
Lista< T >
-private T ini;
+ public boolean vacia(); -private ListaSE<T> sig;
+public void insertar( T dato);
+public ListaSE()
+public void insertar(T dato , int pos);
+public boolean vacia()
+public T eliminar(int pos);
+public void insertar(T dato)
+public T eliminar(T dato);
-private void setDato(T dato)
+public T acceder(int pos);
-private void setSig(ListaSE<T> lista)
+public T acceder(T dato);
+public void insertar(T dato , int pos)
+public boolean buscar(T dato);
+public T eliminar(int pos)
+public int indiceDe(T dato);
+public T eliminar(T dato)
+public int longitud();
+public T acceder(int pos)
+public boolean intercambiar(int
pos1 , int pos2); +public T acceder(T dato)

+ public void reemplazar(T dato , int + public boolean buscar(T dato)

pos );
+public int indiceDe(T dato)
+public boolean compararDatos(int
+public int longitud()
pos1 , int pos2);
 +public boolean equals( Lista<T>
otraLista);
+ public Lista<T> clonar();
+public void vaciar();
+ public String toString ();
+public void invertir();
+public boolean intercambiar(int pos1 , int
pos2)
+public void reemplazar(T dato , int pos )
-private T buscar(int pos)
+public boolean compararDatos(int pos1 , int
pos2)

+public void insertarTodos(Lista<T> +public void vaciar()

otraLista); -private String toString2()

+public String toString

ListaSEC<T> -private T buscarUlt()

+public void recorrer(int pos)

-private NodoSE<T> ini;
-private void recorrer(int pos , int i)
+public ListaSEC()
-private void vaciarPenSig( T iniUlt )
+public NodoSE<T> getIni()
+public void invertir()
+public boolean vacia()
-private void invertir(int tam,int i)
+public void insertar(T dato)
+public boolean equals( Lista<T> otraLista)
+private NodoSE<T> buscarUlt(NodoSE<T> ini
-private boolean equals(Lista<T> otraLista
,NodoSE<T> iniAux)
,int tam,int i)
+public NodoSE<T> buscar(NodoSE<T> q , int
+ public Lista<T> clonar()
pos)
-private ListaSE<T> clonar(int tam ,int i,
+public void insertar(T dato , int pos)
ListaSE<T> clon)
+public T eliminar(int pos)
+public void insertarTodos(Lista<T> otraLista)
+public T eliminar(T dato)
-private void insertar(int i,int tam,Lista<T>
-private NodoSE<T> buscar(NodoSE<T> i, T otraLista)
dato)

-private NodoSE<T> buscarAnt(NodoSE<T>

i,NodoSE<T> p)

+public T acceder(int pos)

+public T acceder(T dato)

+public boolean buscar(T dato)

+public int indiceDe(T dato)

-private int buscarInd(NodoSE<T> i,T dato)

-private int tamanio(NodoSE<T> i) NodoSE<T>
+public int longitud()

+public boolean intercambiar(int pos1 , int -private T dato ;

pos2)
- private NodoSE<T> sucesor;
-private void reemplazar(NodoSE<T>
nodoActual ,T dato , int pos , int i ) +public NodoSE(T dato )

+public void reemplazar(T dato , int pos ) +public NodoSE<T> getSuc()

+public boolean compararDatos(int pos1 , int + public void setSuc(NodoSE<T> q)

pos2) +public void setDato(T otroDato)
-private boolean equals(NodoSE<T> +public T getDato()
nodoActual ,Lista<T> otraLista ,int tam , int i )

+public boolean equals( Lista<T> otraLista)

+private ListaSEC<T> clonar( NodoSE<T>

NodoDE<T>
nodoActual ,int tam , int i , ListaSEC<T> clon )
-private NodoDE<T> antecesor;
+public Lista<T> clonar()
-private T dato ;
+public void vaciar()
-private NodoDE<T> sucesor;

+public NodoDE( T dato)

ListaDE<T> +public void setDato( T dato)

-private NodoDE<T> ini; + public void setAnt(NodoDE<T> ant)

+public void setSuc(NodoDE<T> suc)

+public ListaDE()
+public NodoDE<T> getSuc()
+public NodoDE<T> getIni()
+public NodoDE<T> getAnt()
+public boolean vacia()
+public T getDato()
+public void insertar(T dato)

-private NodoDE<T> buscarUlt(NodoDE<T> ListaDEC<T>

nodoActual)

+public void insertar(T dato , int pos) -private NodoDE<T> ini;

+public T eliminar(int pos)
+public ListaDEC()
-private NodoDE<T> buscar(NodoDE<T> q , int
pos) +public boolean vacia()

-private NodoDE<T> buscar(NodoDE<T> q , T +public void insertar(T dato)

dato) +public void insertar(T dato , int pos)
-private int tamanio(NodoDE<T> i) +public T eliminar(int pos)
+public T eliminar(T dato) -private NodoDE<T> buscar(NodoDE<T> q , int
+public T acceder(int pos) pos)

+public T acceder(T dato) -private NodoDE<T> buscar(NodoDE<T> q , T

dato)
+public boolean buscar(T dato)
+public T eliminar(T dato)
+public int indiceDe(T dato)
-private int buscarInd(NodoDE<T> p,T dato)
+public int longitud()
+public boolean intercambiar(int pos1 , int
pos2)
-private void reemplazar( NodoDE<T> nodo ,T
dato , int pos,int i )
+public void reemplazar(T dato , int pos )
+public boolean compararDatos(int pos1 , int
pos2)
+public void vaciar()
-private String toString(int tam ,NodoDE nodo
,int i)
+public String toString ()
-private void invertir( NodoDE<T>
nodoActual,NodoDE<T> ult,int tam , int i)
+public void invertir()
-private void insertarTodos(Lista<T> otraLista
, int tam , int i)
+public void insertarTodos(Lista<T> otraLista)
-private boolean equals( Lista<T> otraLista,int
tam , int i)
+public boolean equals( Lista<T> otraLista)
-private ListaDE<T> clonar(int tam , int i ,
ListaDE<T> clon,NodoDE<T> nodoActual)
+public Lista<T> clonar()
+public T acceder(int pos)
+public T acceder(T dato)
+public boolean buscar(T dato)
-private int tamanio(NodoDE<T> i)
-private int buscarPos(NodoDE<T> q , T dato)
+public int indiceDe(T dato)
+public int longitud()
+public boolean intercambiar(int pos1 , int
pos2)
-private void reemplazar( NodoDE<T> nodo ,T
dato , int pos,int i )
+public void reemplazar(T dato , int pos )
+public boolean compararDatos(int pos1 , int
pos2)
-private boolean equals( Lista<T> otraLista,int
tam , int i)
+public boolean equals( Lista<T> otraLista)
-private ListaDEC<T> clonar(int tam , int i ,
ListaDEC<T> clon,NodoDE<T> nodoActual)
+public Lista<T> clonar()
+public void vaciar()
-private String toString(int tam ,NodoDE nodo
,int i)
+public String toString ()
-private NodoDE<T> buscarUlt(NodoDE<T>
nodoActual)
-private void invertir( NodoDE<T>
nodoActual,NodoDE<T> ult,int tam , int i)
+public void invertir()
-private void insertarTodos(Lista<T> otraLista ,
int tam , int i)
+public void insertarTodos(Lista<T> otraLista)
CODIGO DE FUENTE:
package estDatLin.EstLin;
public interface Lista<T>{
/**
* permite saber el estado actual de la lista
*/
public boolean vacia();
/**
* insertar el dato al final de la lista
* param -> dato a insertar de clase T
* return nada
*/
public void insertar( T dato);
public void insertar(T dato , int pos);
/**

* elimina el dato de la posicion , en caso de existir y ademas devuelve el dato

eliminado
* param -> pos es un etero postivo incluido el 0
* return el dato eliminado si existiera
*/
public T eliminar(int pos);
/**
* elimina el dato de la lsita si existiera
* para -> dato a eliminar de clase T
* return el dato eliminado si existiera
*/
public T eliminar(T dato);
/**
* accede al dato de la posicion pos si existiera
* param -> pos entero positivo incluido
 * return el dato accedido
*/
public T acceder(int pos);
/**
* acceder al dato de la coleccion
* param -> dato a ser accedido de clase T
* return dato accedido
*/
public T acceder(T dato);
/**
* inserta dato en la posicion pos
* param -> dato de clase T a insertar
* param -> pos en la que se quiere insertar pos >= 0 entero
* return nada
*/
public boolean buscar(T dato);
public int indiceDe(T dato);
public int longitud();
public boolean intercambiar(int pos1 , int pos2);
public void reemplazar(T dato , int pos );
public boolean compararDatos(int pos1 , int pos2);
public boolean equals( Lista<T> otraLista);
public Lista<T> clonar();

public void vaciar();

public String toString ();
public void invertir();
public void insertarTodos(Lista<T> otraLista);
}
package estDatLin.EstLin;
public class ListaSE<T> implements Lista<T>{
private T ini;
private ListaSE<T> sig;
public ListaSE(){

ini = null;
sig = null;
}
/**
* permite saber el estado actual de la lista
*/
public boolean vacia(){
return ini == null;
}
/**
* insertar el dato al final de la lista
* param -> dato a insertar de clase T
* return nada
*/
public void insertar(T dato){
if( vacia() ){
ni = dato ;
ig = new ListaSE<T>();
}else{
sig.insertar(dato);
}
}
private void setDato(T dato)
 ini = dato;
}
private void setSig(ListaSE<T> lista){
sig = lista;
}
public void insertar(T dato , int pos){
T iniAux;
ListaSE<T> sigAux;
if( vacia() ){
if(pos == 0){
ini = dato ;
sig = new ListaSE<T>();
}
}else{
if( pos == 0 ){
sig.insertar(ini,0);
ini = dato ;
}else{
sig.insertar( dato , pos-1 );
}
}
}/**
* elimina el dato de la posicion , en caso de existir y ademas devuelve el dato
eliminado
* param -> pos es un etero postivo incluido el 0
* return el dato eliminado si existiera
*/public T eliminar(int pos){
T res ;
if( vacia() ){
res = null } else{
 if ( pos == 0 ){
res = ini ;
ini = sig.ini;
sig = sig.sig;
}else{
res= sig.eliminar(pos-1);
}
}
return res; /**
* elimina el dato de la lsita si existiera
* para -> dato a eliminar de clase T
* return el dato eliminado si existiera
*/
public T eliminar(T dato){
T res;
if( vacia() ){
res = null } else{
if(ini == dato ){
res = ini ;
ini = sig.ini;
sig = sig.sig; } else{
res = sig.eliminar(dato)
} return res;
/** * accede al dato de la posicion pos si existiera
* param -> pos entero positivo incluido 0
* return el dato accedido
* public T acceder(int pos){
T res;
if( vacia() ){
 res = null } else{
if( pos == 0 ){
res = ini ;
}else{
res = sig.acceder( pos-1);
}
} return res;
} /**
* acceder al dato de la coleccion
* param -> dato a ser accedido de clase T
* return dato accedido
*/public T acceder(T dato){
T res ;

if( vacia() ){
res = null;
}else{
if(ini.equals(dato) ){
res = ini ;
}else{
res = sig.acceder(dato) ;
}
}
return res;
} /**
* inserta dato en la posicion pos
* param -> dato de clase T a insertar
* param -> pos en la que se quiere insertar pos >= 0 entero
* return nada
 */ public boolean buscar(T dato){
boolean res ;
if( vacia() ){
res =false;
}else{
if(ini.equals(dato) ){
res = true ;
}else{
res = sig.buscar(dato) ;
}
} return res;
}
public int indiceDe(T dato){
int res;
if( vacia() ){
res = -1;
}else{
if(ini == dato ){
res = 0;
}else{
res = sig.indiceDe(dato);

if(res != -1) res ++;

}
return res;
}
 public int longitud(){
int res;
if(ini == null){
res = 0 ;
}else{
res = 1 + sig.longitud();
} return res;
}
public boolean intercambiar(int pos1 , int pos2){
boolean sol= false;
if( !vacia() ){

int tam = longitud() ;

if(pos1 < tam && pos2 < tam){
sol = true ;
}
}
return sol;
}
public void reemplazar(T dato , int pos ){
if(!vacia() ){
if(pos == 0){
ini = dato;
}else{
sig.reemplazar(dato , pos-1 );
}
}
}
private T buscar(int pos){
T dato;
if( vacia() ){
dato = null;
}else{
if( pos == 0 ){
dato = ini ;
}else{
dato = sig.buscar(pos-1);
}
}
return dato;
}
public boolean compararDatos(int pos1 , int pos2){
boolean sol = false;
int tam = longitud();
if( pos1 < tam && pos2 < tam ){
T dat1 ,dat2;
dat1 = buscar(pos1);
dat2 = buscar(pos2);
if(dat1.equals(dat2) ){
sol = true;
}
}
return sol;
}
public void vaciar(){
ini = null;
sig = null;
 }

private String toString2(){

String sol ="";

if(sig.ini == null){
sol = ini +"";
}else{
sol = ini +", "+sig.toString2() ;

}
return sol;
}
public String toString (){
String sol ="[";
if( vacia() ){
sol = sol+"]";
}else{
sol = sol + toString2() +"]";
}
return sol;
}
private T buscarUlt(){
T ult ;
if(sig.ini == null ){
ult = ini;
}else{
ult = sig.buscarUlt();
 }
return ult;
}
public void recorrer(int pos){
if( ini != null ){
if(longitud() != 1 ){
recorrer(pos, 0);
}
}
}
private void recorrer(int pos , int i){
ListaSE<T> aux1,aux2;
if(i < pos){
T iniUlt = buscarUlt();
vaciarPenSig(iniUlt);
aux1 = new ListaSE<T>();
aux2 = sig ;
aux1.setDato(ini);
aux1.setSig(aux2);
ini = iniUlt;
sig = aux1;
recorrer(pos,i+1);
}
private void vaciarPenSig( T iniUlt ){

if(sig.ini!= null){
if(sig.ini.equals(iniUlt) && sig.sig.ini == null){
sig.setDato(null);
sig.setSig(null);
 }else{
sig.vaciarPenSig( iniUlt );
}
}

public void invertir(){

if( ini!=null){
recorrer(1);
int tam =longitud();
if(tam >2)
invertir(tam-1,1);
}
}

private void invertir(int tam,int i){

ListaSE<T> aux1,aux2;
if(i < tam){
T iniUlt = buscarUlt();
vaciarPenSig(iniUlt);
aux1 = new ListaSE<T>();
aux2 = sig ;
aux1.setDato(iniUlt);
aux1.setSig(aux2);
sig= aux1;
sig.invertir(tam,i+1);
 }
}
public boolean equals( Lista<T> otraLista){
boolean sol = false;;
if( !vacia() && !otraLista.vacia() ){
int tam = longitud();
if(tam == otraLista.longitud() ){
sol = equals(otraLista ,tam,0);
}

return sol;
}

private boolean equals(Lista<T> otraLista ,int tam,int i){

boolean sol = true;

if(i < tam ){

T iniOtra = otraLista.acceder(i);
if( ini.equals(iniOtra)){
sol = true && sig.equals(otraLista , tam, i+1);

}else{
sol = false;

}
 return sol;
}

public Lista<T> clonar(){

int tam ;

tam = longitud();

return clonar(tam,0,new ListaSE<T>() );

}

private ListaSE<T> clonar(int tam ,int i, ListaSE<T> clon){

ListaSE<T> lista = clon ;

if(i < tam ){

lista.insertar(ini);
lista = sig.clonar(tam , i+1,clon);

}
return lista;
}

public void insertarTodos(Lista<T> otraLista){

if( vacia() ){
int tam = otraLista.longitud();
insertar(0,tam,otraLista);
 }else{
if(sig.ini == null){
int tam = otraLista.longitud();
insertar(0,tam,otraLista);
}else{
sig.insertarTodos(otraLista);
}
}
}
private void insertar(int i,int tam,Lista<T> otraLista){
if( i < tam ){
T datoOtra = otraLista.acceder(i);
insertar(datoOtra);
insertar( i+1 ,tam,otraLista);
}
}
}
--------------------------------------
package estDatLin.EstLin;
public class ListaSEC<T> implements Lista<T>{
private NodoSE<T> ini;

/**
* permite saber el estado actual de la lista
*/
public ListaSEC(){
ini = null;
}
public NodoSE<T> getIni(){
return ini;
}

public boolean vacia(){

return ini == null;

}

/**
* insertar el dato al final de la lista
* param -> dato a insertar de clase T
* return nada
*/
public void insertar(T dato){
NodoSE<T> q,ult ;
q = new NodoSE<T>(dato);

if( vacia() ){
ini = q;
ini.setSuc(q);
}else{
ult = buscarUlt(ini,ini);
ult.setSuc(q);
q.setSuc(ini);
}
}

private NodoSE<T> buscarUlt(NodoSE<T> ini ,NodoSE<T> iniAux){

 NodoSE<T> elNodo,aux ;

aux = iniAux.getSuc();
if(aux== ini){
elNodo = iniAux ;
}else{
elNodo = buscarUlt(ini,iniAux.getSuc() );
}
return elNodo;
}

public NodoSE<T> buscar(NodoSE<T> q , int pos){

NodoSE<T> elNodo;
if(pos == 0 ){
elNodo = q;
}else{

elNodo = buscar(q.getSuc() , pos-1);

}
return elNodo;
}

public void insertar(T dato , int pos){// q el nodo que vamos insertar
NodoSE<T> ult, s ,q ,p,antP;
if( vacia() ){
ini = new NodoSE<T>(dato);
}else{
q = new NodoSE(dato);
ult = buscarUlt(ini,ini);
 if( pos == 0 ){

s = ini.getSuc();
q.setSuc(s);
ult.setSuc(q);
ini = q;

}else{

if(pos == longitud() ){
ult = buscarUlt(ini,ini);
ult.setSuc(q);
q.setSuc(ini);

}else{
p = buscar(ini,pos);
antP = buscar(ini,pos-1);
antP.setSuc(q);
q.setSuc(p);

}
}
}

/**
* elimina el dato de la posicion , en caso de existir y ademas devuelve el dato
eliminado
* param -> pos es un etero postivo incluido el 0
* return el dato eliminado si existiera
*/
public T eliminar(int pos){
T res;
NodoSE<T> q,suc,ult,antQ;

if( vacia() ){
res = null;

}else{

if(pos == 0 ){
q = buscar(ini,pos) ;
res = q.getDato();
suc = q.getSuc();
if( q==suc ){
ini = null;
}else{
ult = buscarUlt(ini,ini);
ini = suc;
ult.setSuc(suc);

}else{
q = buscar(ini,pos);
res = q.getDato();
antQ = buscar(ini,pos-1);
suc = q.getSuc();
 antQ.setSuc(suc);
}
}
return res;
}

/**
* elimina el dato de la lsita si existiera
* para -> dato a eliminar de clase T
* return el dato eliminado si existiera
*/
public T eliminar(T dato){
T res;
NodoSE<T> p,antP,s;

if( vacia() ){
res = null;
}else{
p = buscar(ini, dato);
if(p == null ){
res = null;
}else{

antP = buscarAnt(ini,p);
res = p.getDato();
s = p.getSuc();
antP.setSuc(s);

}
 }
return res;
}

private NodoSE<T> buscar(NodoSE<T> i, T dato){

NodoSE<T> elNodo ;
if(i.getDato().equals(dato) ){
elNodo = i ;
}else{
if(i.getSuc() == ini ){
elNodo = null;

}else{
elNodo = buscar( i.getSuc(), dato);
}

return elNodo;
}

private NodoSE<T> buscarAnt(NodoSE<T> i,NodoSE<T> p){//buscar el anterior a p

NodoSE<T> elNodo ;

if(i.getSuc() == p){
elNodo = i ;

}else{
 if(i.getSuc() == ini){
elNodo = null;
}else{
elNodo = buscarAnt( i.getSuc(), p);
}

}
return elNodo;
}

/**
* accede al dato de la posicion pos si existiera
* param -> pos entero positivo incluido 0
* return el dato accedido
*/

public T acceder(int pos){// p nodo a buscar que vive en la posicion pos

T res;
NodoSE<T> p ;

if( vacia() ){
res = null;
}else{
if(pos < longitud() ){
p = buscar(ini, pos);
res = p.getDato();

}else{
 res = null;
}
}

return res;
}

/**
* acceder al dato de la coleccion
* param -> dato a ser accedido de clase T
* return dato accedido
*/

public T acceder(T dato){// p nodo donde vive el dato

T res;
NodoSE<T> p ;
if( vacia() ){
res = null;
}else{
p = buscar(ini,dato);
if(p == null){
res = null;
}else{
res = p.getDato();
}
}

return res;
}
/**
* inserta dato en la posicion pos
* param -> dato de clase T a insertar
* param -> pos en la que se quiere insertar pos >= 0 entero
* return nada
*/

public boolean buscar(T dato){

boolean res;

NodoSE<T> p ;
if( vacia() ){
res = false;
}else{
p = buscar(ini,dato);
if(p == null){
res = false;
}else{
res = true;
}
}

return res;
}

public int indiceDe(T dato){

int indice ;
if( vacia() ){
 indice = -1 ;
}else{
indice = buscarInd(ini,dato);

}
return indice;
}

private int buscarInd(NodoSE<T> i,T dato){

int res;

if(i.getDato().equals(dato)){
res = 0 ;
}else{
if(i.getSuc() == ini ){
res = -1;
}else{
res = buscarInd( i.getSuc(), dato) ;
if(res !=-1) res++;

}
return res;
}

private int tamanio(NodoSE<T> i){

int cont = 1 ;
if(i == null){
 cont = 0 ;

}else{

if(i.getSuc() == ini ){
cont = cont;
}else{
cont = 1+tamanio(i.getSuc()) ;
}

}
return cont;
}

public int longitud(){

return tamanio(ini);
}

public boolean intercambiar(int pos1 , int pos2){

boolean sol = false;
if( !vacia() ){
int tam = longitud() ;
if(pos1 < tam && pos2 < tam){
sol = true;
}
}
return sol;
}
private void reemplazar(NodoSE<T> nodoActual ,T dato , int pos , int i ){
if(i == pos){
nodoActual.setDato(dato);

}else{
reemplazar(nodoActual.getSuc() , dato , pos , i+1 );
}
}

public void reemplazar(T dato , int pos ){

int tam = longitud();

reemplazar(ini ,dato , pos , 0 );

public boolean compararDatos(int pos1 , int pos2){

boolean sol = false;

if( !vacia() ){
NodoSE<T> nodo1 = buscar(ini, pos1);
NodoSE<T> nodo2 = buscar(ini, pos2);

T dato1 = nodo1.getDato() ;
T dato2 = nodo2.getDato() ;

if(dato1.equals(dato2) ){
sol = true;
}
 }
return sol;
}

private boolean equals(NodoSE<T> nodoActual ,Lista<T> otraLista ,int tam , int i ){

boolean sol = false; ;

if( i < tam ){

T datoActual = nodoActual.getDato();
T otroDato = otraLista.acceder(i);

if( datoActual.equals(otroDato)){
sol = true && equals( nodoActual.getSuc() ,otraLista , tam , i+1 ) ;
}

}
return sol;
}

public boolean equals( Lista<T> otraLista){

boolean sol;

if( vacia() ){
sol = false;

}else{
int tam = longitud() ;
 sol = equals(ini,otraLista , tam , 0 );

}
return sol;
}

private ListaSEC<T> clonar( NodoSE<T> nodoActual ,int tam , int i , ListaSEC<T> clon
){

if( i < tam ){

clon.insertar( nodoActual.getDato() );
clon = clonar( nodoActual.getSuc() , tam , i+1 , clon );

return clon;
}

public Lista<T> clonar(){

int tam = longitud() ;
return clonar(ini , tam , 0 , new ListaSEC<T>() );
}

public void vaciar(){

ini = null;
}

private String toString ( NodoSE<T> nodoActual ,int tam , int i){

String sol ="";
 if(i < tam ){
if(i+1 == tam ){
sol = nodoActual.getDato()+ "";
}else{
sol = nodoActual.getDato() + ", "+toString ( nodoActual.getSuc() , tam , i+1);
}
}
return sol;
}

public String toString (){

String sol = "[";

if( vacia() ){
sol = sol + "]";
}else{
int tam = longitud() ;
sol = sol + toString ( ini ,tam , 0) + "]" ;
}
return sol ;
}

private void invertir( NodoSE<T> nodoActual , NodoSE<T> ult ,int tam ,int i){

if( i < tam ){

NodoSE<T> nodoAntUlt = buscarAnt(nodoActual, ult);
T datoActual = nodoActual.getDato();
nodoActual.setDato(ult.getDato());
 ult.setDato(datoActual);
invertir( nodoActual.getSuc() , nodoAntUlt , tam , i+1);
}
}

public void invertir(){

int tam = longitud() ;

if(!vacia() ){
NodoSE<T> ult = buscarUlt(ini, ini);

invertir( ini , ult ,tam/2 , 0);

}
}

private void insertarTodos(Lista<T> otraLista , int tam , int i){

if( i < tam ){

T datoOtra = otraLista.acceder(i);
insertar(datoOtra);
insertarTodos( otraLista , tam , i+1);

public void insertarTodos(Lista<T> otraLista){

int tam = otraLista.longitud();
 insertarTodos( otraLista , tam , 0);
}
}
--------------------------------------
package estDatLin.EstLin;
public class NodoSE<T>{
private T dato ;
private NodoSE<T> sucesor;

public NodoSE(T dato ){

this.dato = dato;
sucesor = null;

public NodoSE<T> getSuc(){

return sucesor;
}

public void setSuc(NodoSE<T> q){

sucesor = q;
}

public void setDato(T otroDato){

dato = otroDato;
}

public T getDato(){
 return dato;
}
}
-----------------------------------------------------
package estDatLin.EstLin;

public class NodoDE<T>{

private NodoDE<T> antecesor;

private T dato ;
private NodoDE<T> sucesor;

public NodoDE( T dato){

sucesor = null ;
this.dato = dato ;
antecesor = null ;
}

public void setDato( T dato){

this.dato = dato;
}

public void setAnt(NodoDE<T> ant){

antecesor = ant ;

public void setSuc(NodoDE<T> suc){

sucesor = suc ;
 }

public NodoDE<T> getSuc(){

return sucesor;
}

public NodoDE<T> getAnt(){

return antecesor;
}

public T getDato(){
return dato;

}
}
-----------------------------------------------------------------

package estDatLin.EstLin;

public class ListaDE<T> implements Lista<T>{

private NodoDE<T> ini;
/**
* permite saber el estado actual de la lista
*/

public ListaDE(){
 ini = null;
}

public NodoDE<T> getIni(){

return ini;
}

public boolean vacia(){

return ini == null;

}

/**
* insertar el dato al final de la lista
* param -> dato a insertar de clase T
* return nada
*/
public void insertar(T dato){
NodoDE<T> p ,ult;
p = new NodoDE<T>(dato);

if( vacia() ){
ini = p ;
}else{
ult = buscarUlt(ini);
ult.setSuc(p);
p.setAnt(ult);

}
}

private NodoDE<T> buscarUlt(NodoDE<T> nodoActual){

if(nodoActual.getSuc()!= null){
nodoActual= buscarUlt(nodoActual.getSuc() );

}
return nodoActual;
}

public void insertar(T dato , int pos){// q nodo a insertar y p nodo a buscar
NodoDE<T> q,p,a ;

if( vacia() ){

if(pos == 0 ){
ini = new NodoDE<T>(dato);
}

}else{
if( pos == 0 ){
p = buscar(ini,pos);
q = new NodoDE<T>(dato);
q.setSuc(p);
p.setAnt(q);
ini = q ;

}else{
 if(pos == longitud() ){
p = buscar(ini,pos-1);
q = new NodoDE<T>(dato);
p.setSuc(q);
q.setAnt(p);

}else{
p = buscar(ini,pos);
a = p.getAnt();
q = new NodoDE<T>(dato);
a.setSuc(q);
q.setAnt(a);
p.setAnt(q);
q.setSuc(p);

}
}

/**
* elimina el dato de la posicion , en caso de existir y ademas devuelve el dato
eliminado
* param -> pos es un etero postivo incluido el 0
* return el dato eliminado si existiera
*/
public T eliminar(int pos){
T res;

if( vacia() ){
res = null;
}else{
NodoDE<T> q,a,s,ult;

if(pos < longitud() ){

ult = buscarUlt(ini);
q = buscar(ini,pos);
res = q.getDato() ;
s = q.getSuc() ;
a = q.getAnt() ;

if(q == ini ){

if(s == null && a == null){

ini = s;
}else{

s.setAnt(a);
ini = s;
}

}else{
if(q == ult ){
a.setSuc(s);
}else{
s.setAnt(a);
 a.setSuc(s);

}
}
}else{
res = null;
}

}
return res;
}

private NodoDE<T> buscar(NodoDE<T> q , int pos){

NodoDE<T> elNodo;
if(pos < longitud() ){

if(pos == 0 ){
elNodo = q;
}else{
elNodo = buscar(q.getSuc() , pos-1);
}

}else{
elNodo = null;
}

return elNodo;
}
private NodoDE<T> buscar(NodoDE<T> q , T dato){
NodoDE<T> elNodo;
if(q == null){
elNodo = null;
}else{
if(q.getDato().equals(dato) ){
elNodo = q;
}else{
elNodo = buscar(q.getSuc() , dato);

}
return elNodo;
}

private int tamanio(NodoDE<T> i){

int contador = 0 ;
if(i != null){
contador = 1 + tamanio(i.getSuc());

}
return contador;
}

/**
* elimina el dato de la lsita si existiera
* para -> dato a eliminar de clase T
* return el dato eliminado si existiera
*/
public T eliminar(T dato){ // p nodo donde vive el dato a eliminar
T res ;
NodoDE<T> p,a,s,ult;
if( vacia() ){
res = null;
}else{
p = buscar(ini,dato);
if(p == null ){
res = null;
}else{
ult = buscarUlt(ini);
if(p == ini ){
a = p.getAnt();
s = p.getSuc();
s.setAnt(a);
ini = s;
res =p.getDato();
}else{
if(p == ult){
s = p.getSuc();
a = p.getAnt();
a.setSuc(s);
res = p.getDato();
}else{
s = p.getSuc();
a = p.getAnt();
a.setSuc(s);
s.setAnt(a);
 res = p.getDato();
}

}
}
}
return res;
}

/**
* accede al dato de la posicion pos si existiera
* param -> pos entero positivo incluido 0
* return el dato accedido
*/

public T acceder(int pos){

T res;
NodoDE<T> p ;

if( vacia() ){
res = null;

}else{
if( pos== 0 ){
res = ini.getDato() ;
}else{
p = buscar(ini,pos);
if( p == null ){
res = null;
 }else{
res = p.getDato();
}
}

return res;
}

/**
* acceder al dato de la coleccion
* param -> dato a ser accedido de clase T
* return dato accedido
*/

public T acceder(T dato){

T res;
NodoDE<T> p ;
if( vacia() ){
res = null;
}else{
p = buscar(ini,dato);

if( p == null ){
res = null;
}else{
res = p.getDato();
}
 }

return res;
}

/**
* inserta dato en la posicion pos
* param -> dato de clase T a insertar
* param -> pos en la que se quiere insertar pos >= 0 entero
* return nada
*/

public boolean buscar(T dato){

boolean res;
NodoDE<T> p ;

if( vacia() ){
res = false;
}else{
p = buscar(ini,dato);

if( p == null ){
res = false;
}else{
res = true;
}

}
 return res;
}

public int indiceDe(T dato){

int res;
if( vacia() ){
res = -1 ;
}else{
res = buscarInd(ini,dato);
}

return res;
}

private int buscarInd(NodoDE<T> p,T dato){

int res;
if(p.getDato().equals(dato) ){
res = 0 ;
}else{
if( p == null ){
res = -1 ;
}else{
res = buscarInd(p.getSuc(),dato);
if(res != -1 )res ++;

}
 return res;
}

public int longitud(){

return tamanio(ini);
}

public boolean intercambiar(int pos1 , int pos2){

boolean sol;
if(vacia() ){
sol = false;
}else{
int tam = longitud() ;
if( pos1 < tam && pos2 < tam){
sol = true;
}else{
sol =false;

}
}
return sol;
}

private void reemplazar( NodoDE<T> nodo ,T dato , int pos,int i ){

if(i == pos){
nodo.setDato(dato);
}else{
reemplazar( nodo.getSuc() , dato ,pos, i+1 );
}
}

public void reemplazar(T dato , int pos ){

if( !vacia() ){
int tam = longitud();
if( pos < tam ){
reemplazar( ini ,dato , pos, 0 );
}

}
}

public boolean compararDatos(int pos1 , int pos2){

boolean sol = false;

int tam = longitud();

if( pos1 < tam && pos2 < tam ){
NodoDE<T> nodo1 = buscar(ini, pos1);
NodoDE<T> nodo2 = buscar(ini, pos2);

T dato1 = nodo1.getDato();
T dato2 = nodo2.getDato();
if( dato1.equals(dato2) ){
sol = true;
}

}
return sol;
}

public void vaciar(){

ini = null;
}

private String toString(int tam ,NodoDE nodo ,int i){

String sol ="";
if( i < tam ){

if( i+1 == tam){

sol = sol + nodo.getDato() ;
}else{
sol = nodo.getDato()+", " + toString(tam ,nodo.getSuc(),i+1);

return sol;
}

public String toString (){

String sol ="[";
if( vacia() ){
sol = sol + "]";
}else{
int tam = longitud() ;
sol =sol+ toString(tam,ini,0)+ "]";
 }
return sol ;
}

private void invertir( NodoDE<T> nodoActual,NodoDE<T> ult,int tam , int i){

if( i < tam){

T auxIni = nodoActual.getDato();
nodoActual.setDato(ult.getDato());
ult.setDato(auxIni);

invertir( nodoActual.getSuc(), ult.getAnt(), tam ,i+1);

public void invertir(){

if(!vacia() ){

if( ini.getSuc()!=null ){
NodoDE<T> ult = buscarUlt(ini);

invertir(ini,ult, longitud()/2 , 0);

}

}
}
private void insertarTodos(Lista<T> otraLista , int tam , int i){
if(i < tam ){
T dato = otraLista.acceder(i);
insertar(dato);
insertarTodos(otraLista , tam , i+1);

public void insertarTodos(Lista<T> otraLista){

insertarTodos(otraLista , otraLista.longitud() , 0);
}

private boolean equals( Lista<T> otraLista,int tam , int i){

boolean sol = true;

if( i < tam){

T datoOtra = otraLista.acceder(i);
if( ini.getDato().equals(datoOtra) ){
sol = true && equals( otraLista, tam , i+1);

}else{
sol =false;

}
 return sol;
}

public boolean equals( Lista<T> otraLista){

boolean sol ;

if( vacia() ){
sol = false;
}else{
sol = equals( otraLista, longitud() , 0);

}
return sol;
}

private ListaDE<T> clonar(int tam , int i , ListaDE<T> clon,NodoDE<T> nodoActual){

if( i < tam ){

clon.insertar( nodoActual.getDato() );
clon = clonar(tam,i+1,clon,nodoActual.getSuc());
}
return clon;
}

public Lista<T> clonar(){

int tam = longitud();
return clonar(tam , 0 , new ListaDE<T>(),ini);
}
}
----------------------------------------------------

package estDatLin.EstLin;
public class ListaDEC<T> implements Lista<T>{
private NodoDE<T> ini;

public ListaDEC(){
ini = null;
}

/**
* permite saber el estado actual de la lista
*/
public boolean vacia(){

return ini == null;

}

/**
* insertar el dato al final de la lista
* param -> dato a insertar de clase T
* return nada
*/
public void insertar(T dato){//p seria el nodo a insertar
NodoDE<T> p,ult;
p = new NodoDE<T>(dato);

if( vacia() ){
ini = p ;
 p.setSuc(p);
p.setAnt(p);

}else{
ult = ini.getAnt();
ult.setSuc(p);
p.setSuc(ini);
p.setAnt(ult);
ini.setAnt(p);

}
}

public void insertar(T dato , int pos){// q nodo a insertar y p nodo que vive en esa
posicion
NodoDE<T> a,s,p,q;
if( vacia() ){

if(pos == 0 ){

ini = new NodoDE<T>(dato);

ini.setAnt(ini);
ini.setSuc(ini);

}else{

p = buscar(ini,pos);
q = new NodoDE<T>(dato);
 a = p.getAnt();
q.setSuc(p);
q.setAnt(a);
p.setAnt(q);
a.setSuc(q);

}
}

/**
* elimina el dato de la posicion , en caso de existir y ademas devuelve el dato
eliminado
* param -> pos es un etero postivo incluido el 0
* return el dato eliminado si existiera
*/
public T eliminar(int pos){
T res;
if( vacia() ){
res = null ;
}else{

NodoDE<T> s,q,a;
q = buscar(ini,pos);
a = q.getAnt();
s = q.getSuc();
res = q.getDato();
a.setSuc(s);
s.setAnt(a);
if(q == ini) ini = s ;
if(q == a) ini = null;
 }
return res;
}

private NodoDE<T> buscar(NodoDE<T> q , int pos){

NodoDE<T> elNodo;
if(pos == 0 ){
elNodo = q;
}else{

elNodo = buscar(q.getSuc() , pos-1);

}
return elNodo;
}

private NodoDE<T> buscar(NodoDE<T> q , T dato){

NodoDE<T> elNodo;
if(q.getDato().equals(dato)){
elNodo = q;
}else{
if(q.getSuc()==ini){
elNodo = null;
}else{
elNodo = buscar(q.getSuc() , dato);
}
}
return elNodo;
}
/**
* elimina el dato de la lsita si existiera
* para -> dato a eliminar de clase T
* return el dato eliminado si existiera
*/
public T eliminar(T dato){
T res ;
NodoDE<T> q,s,a;
if( vacia() ){
res = null;

}else{
q = buscar(ini,dato);

if(q == null ){
res = null;

}else{
res = q.getDato();
a = q.getAnt();
s = q.getSuc();

s.setAnt(a);
a.setSuc(s);
if(q==ini){
ini =s;
}
if(s == q ){
 ini = null;
}

}
return res;
}

/**
* accede al dato de la posicion pos si existiera
* param -> pos entero positivo incluido 0
* return el dato accedido
*/

public T acceder(int pos){

T res;
NodoDE<T> q;

if( vacia() ){
res = null;
}else{
if( pos == 0 ){
res = ini.getDato();

}else{
q = buscar(ini,pos);
res= q.getDato() ;
 }

return res;
}

/**
* acceder al dato de la coleccion
* param -> dato a ser accedido de clase T
* return dato accedido
*/

public T acceder(T dato){

T res;
NodoDE<T> q;

if( vacia() ){
res = null;
}else{

if(ini.getDato().equals(dato) ){
res = ini.getDato();

}else{
q = buscar( ini , dato);

if(q == null){
res = null;
 }else{
res = q.getDato();
}

}
return res;
}

/**
* inserta dato en la posicion pos
* param -> dato de clase T a insertar
* param -> pos en la que se quiere insertar pos >= 0 entero
* return nada
*/

public boolean buscar(T dato){

boolean res;
NodoDE<T> q;

if( vacia() ){
res = false;
}else{

if(ini.getDato().equals(dato) ){
res = true ;

}else{
 q = buscar( ini , dato);

if(q == null){
res = false;
}else{
res = true;
}

}
return res;

private int tamanio(NodoDE<T> i){

int contador = 1 ;
if(ini == null){
contador = 0;
}else{
if(i != ini.getAnt()){
contador = 1 + tamanio( i.getSuc() );

}
}
return contador;
}

private int buscarPos(NodoDE<T> q , T dato){

 int res ;

if(q.getDato().equals(dato)){
res = 0 ;
}else{
if(q.getSuc()== ini ){
res = -1;
}else{
res= buscarPos(q.getSuc(),dato);

if(res!=-1)res ++;

}
}
return res;
}

public int indiceDe(T dato){

int res ;
if( vacia() ){
res = -1;
}else{
res= buscarPos(ini,dato);

}
return res;
}

public int longitud(){

 return tamanio(ini) ;
}

public boolean intercambiar(int pos1 , int pos2){

boolean sol = false;

if(!vacia() ){
int tam = longitud();
if(pos1 < tam && pos2 < tam ){
sol = true;
}
}

return sol;
}

private void reemplazar( NodoDE<T> nodo ,T dato , int pos,int i ){

if(i == pos){
nodo.setDato(dato);
}else{
reemplazar( nodo.getSuc() , dato ,pos, i+1 );
}

public void reemplazar(T dato , int pos ){

if( !vacia() ){
int tam = longitud();
 if( pos < tam ){
reemplazar( ini ,dato , pos, 0 );
}

}
}

public boolean compararDatos(int pos1 , int pos2){

boolean sol = false;

int tam = longitud();

if( pos1 < tam && pos2 < tam ){
NodoDE<T> nodo1 = buscar(ini, pos1);
NodoDE<T> nodo2 = buscar(ini, pos2);

T dato1 = nodo1.getDato();
T dato2 = nodo2.getDato();
if( dato1.equals(dato2) ){
sol = true;
}

}
return sol;
}

private boolean equals( Lista<T> otraLista,int tam , int i){

boolean sol = true;

if( i < tam){

 T datoOtra = otraLista.acceder(i);
if( ini.getDato().equals(datoOtra) ){
sol = true && equals( otraLista, tam , i+1);

}else{
sol =false;

}
return sol;
}

public boolean equals( Lista<T> otraLista){

boolean sol ;

if( vacia() ){
sol = false;
}else{
sol = equals( otraLista, longitud() , 0);

}
return sol;
}

private ListaDEC<T> clonar(int tam , int i , ListaDEC<T> clon,NodoDE<T> nodoActual){

if( i < tam ){
clon.insertar( nodoActual.getDato() );
clon = clonar(tam,i+1,clon,nodoActual.getSuc());
 }

return clon;
}

public Lista<T> clonar(){

int tam = longitud();
return clonar(tam , 0 , new ListaDEC<T>(),ini);
}

public void vaciar(){

ini = null;
}

private String toString(int tam ,NodoDE nodo ,int i){

String sol ="";
if( i < tam ){

if( i+1 == tam){

sol = sol + nodo.getDato() ;
}else{
sol = nodo.getDato()+", " + toString(tam ,nodo.getSuc(),i+1);

return sol;
}
public String toString (){
String sol ="[";
if( vacia() ){
sol = sol + "]";
}else{
int tam = longitud() ;
sol =sol+ toString(tam,ini,0)+ "]";

}
return sol ;
}

private NodoDE<T> buscarUlt(NodoDE<T> nodoActual){

if(nodoActual.getSuc()!= ini){
nodoActual = buscarUlt(nodoActual.getSuc() );

}
return nodoActual;
}

private void invertir( NodoDE<T> nodoActual,NodoDE<T> ult,int tam , int i){

if( i < tam){

T auxIni = nodoActual.getDato();
nodoActual.setDato(ult.getDato());
ult.setDato(auxIni);
 invertir( nodoActual.getSuc(), ult.getAnt(), tam ,i+1);

public void invertir(){

if(!vacia() ){

if( ini.getSuc()!=null ){
NodoDE<T> ult = buscarUlt(ini);

invertir(ini,ult, longitud()/2 , 0);

}

}
}

private void insertarTodos(Lista<T> otraLista , int tam , int i){

if(i < tam ){
T dato = otraLista.acceder(i);
insertar(dato);
insertarTodos(otraLista , tam , i+1);
}
}
public void insertarTodos(Lista<T> otraLista){
insertarTodos(otraLista , otraLista.longitud() , 0);
}
}