L1.

insertarPrim(x) : Método que }

inserta el elemento x, al inicio p=p.prox;
de la lista L1. }
return c;
public void insertarPrim(int }
x ){ 2. L1.seEncuentra(x) : Método
Nodo q= new Lógico que devuelve True, si
Nodo(null,x,this.prim); el elemento x, se encuentra
if(prim==null) en la lista L1.
this.prim=this.ult=q;
else
this.prim = public boolean
this.prim.ant=q; seEncuentra (int x){
this.cantElm++; Nodo p = this.prim;
while( p != null){
} if (p.elem==x) {
L1.insertarUlt(x) : Método que return true;
inserta el elemento x, al final
}
de la lista L1.
p = p.prox;
public void insetarUlt(int }
x){ return false;
Nodo q= new
Nodo(ult,x,null); }
if(prim==null)
this.prim=this.ult=q; 3. L1.poker() : Método Lógico
else que devuelve True, si los
this.ult = elementos de la lista L1
this.ult.prox=q; forman poker. (Todos los
this.cantElm++; elementos son iguales excepto
uno)
L1.mostrarIzqDer(),
public boolean poker(){
public void mostrarIzqDer(){ Nodo p = this.prim;
Nodo p= this.prim; while (p != null) {
while(p!=null){ if
(frecuencia(p.elem)==
System.out.println(p.elem); this.cantElem-1) {
p = p.prox; return true;
} }
} p = p.prox;
}
1. L1.mostrarDerIzq():Metodo que
return false;
muestra los elementos de la
lista L1 desde el ultimo }
elemento al primero

public void mostrarDerIzq(){

Nodo p= this.ult;
while(p!=null){ 4. L1.insertarLugarAsc(x)
: Método que inserta el
System.out.println(p.elem); elemento x en su lugar, en la
p = p.ant; lista L1 ordenada de menor a
} mayor.
}
public void
L1.frecuencia(x) : Método que insertarNodo(Nodo ap, Nodo
devuelve la cantidad de veces p , int x){
que aparece el elemento x en if(ap == null){
la lista L1. insertarPrim(x);
return;
public int frecuencia (int }
x){ if(p==null){
Nodo p=prim; this.insetarUlt(x);
int c=0; return;
while (p!=null){ }
if (p.elem==x){ Nodo q= new Nodo
c++; (ap,x,p);
 ap.prox=p.ant=q; else{
cantElm++; prim=prim.prox;
} prim.ant=null;
}
cantElm--;
public void }
insertarLugarAsc(int x) {
Nodo p = prim; public void
Nodo ap = null; eliminarInicio(int n)
while (p != null && {
x > p.elem) { int c= 0;
ap = p; while(c<n){
p = p.prox; eliminarPrim();
} c++;
insertarNodo(ap, p, }
x); }
}

5. L1.eliminarTodo(x) : Método 7. L1.eliminarUnicos() :

que elimina todos los Método que elimina todos
elementos x de la lista L1. los elementos que no se
repiten en la lista L1.
public Nodo eliminarNodo(Nodo
ap, Nodo p){ public int frecuencia(int
if(ap == null){ x){
eliminarPrim(); Nodo p = this.prim;
return prim; int c = 0;
}
while (p != null){
if(p.prox==null){
this.eliminarUlt(); if (p.elem == x )
return null; {
} c++;
ap.prox=p.prox; }
cantElm--;
p = p.prox;
return ap.prox;
} }
return c;
public void }
eliminarTodo(int x)
{
Nodo p = prim; 8. L1.eliminarDup(): Método
Nodo ap = null; que elimina los elementos
while (p != null) { duplicados de la lista L1.
if (p.elem == x)
{ public void
p =
eliminarDup()
eliminarNodo(ap, p);
} else { {
ap = p; if (prim == null)
p = p.prox; {
return;
} }
} Nodo p = prim;
} while (p != null)
{
int c =
6. L1.eliminarInicio(n) : Método
que eliminar los primeros n this.frecuencia(p.elem);
elementos de la lista L1. if (c > 1) {

public void eliminarPrim(){ eliminarTodo(p.elem);

if(prim==null){ }
return; p = p.prox;
} }
if(prim==null){ }
prim=ult=null;
}