EJEMPLO 8.

1
package ListaPuntos;

public class Punto

{
double x, y;

public Punto(double x, double y)

{
this.x = x;
this.y = y;
}
public Punto() // constructor por defecto
{
x = y = 0.0;
}
}

package ListaPuntos;

public class Nodo

{
Punto dato;
Nodo enlace;

public Nodo(Punto p)
{
dato = p;
enlace = null;
}
public Nodo(Punto p, Nodo n)
{
dato = p;
enlace = n;
}
}
EJEMPLO 8.2

import [Link].*;
class Nodo
{
int dato;
Nodo enlace;

public Nodo(int x)
{
dato = x;
enlace = null;
}
public Nodo(int x, Nodo n)
{
dato = x;
enlace = n;
}
public int getDato()
{
return dato;
}
public Nodo getEnlace()
{
return enlace;
}
public void setEnlace(Nodo enlace)
{
[Link] = enlace;
}

public class Lista

{
private Nodo primero;

public Lista()
{
primero = null;
}
private int leerEntero()
{
BufferedReader en = new BufferedReader( new
InputStreamReader ([Link]));
int d = -1;

try {
[Link](" Entero: ");
d = [Link]([Link]());
}
catch(Exception o)
{
[Link](" Error entrada: " + o);
}
return d;
}

public Lista crearLista()

{
int x;
 primero = null;
do {
x = leerEntero();
if (x != -1)
{
primero = new Nodo(x,primero);
}
}while (x != -1);
return this;
}
}
EJERCICIO 8.1

package ListaEnteros;

// clase Nodo con las dos partes de un nodo y su constructor

public class Nodo
{
int dato;
Nodo enlace;

public Nodo(int x)
{
dato = x;
enlace = null;
}
}

/* clase Lista con las operaciones: insertar por la cabeza y

visualizar (recorre los nodos) para mostrar los datos. Además,
el atributo primero, que apunta al primer nodo.
*/

package ListaEnteros;

public class Lista

{
private Nodo primero;

public Lista()
{
primero = null;
}
public Lista insertarCabezaLista(int entrada)
{
Nodo nuevo ;
nuevo = new Nodo(entrada);
[Link] = primero;
primero= nuevo;
return this;
}
public void visualizar()
{
Nodo n;
int k = 0;

n = primero;
while (n != null)
{
[Link]([Link] + " ");
n = [Link];
k++;
[Link]( (k%15 != 0 ? " " : "\n"));
}
}
}

// clase con método main

import [Link].*;
import ListaEnteros.*;
public class ListaAleatoria
{
public static void main(String [] a)
{
Random r;
int d;
Lista lista;
int k;

r = new Random();
lista = new Lista(); // crea lista vacía
k = [Link]([Link]() % 55); // número de nodos
// Son insertados elementos en la lista
for (; k > 0; k-- )
{
d = [Link]() % 99 ;
[Link](d);
}
// recorre la lista para escribir sus elementos
[Link]("Elementos de la lista generados al azar");
[Link]();
}
}
EJERCICIO 8.2

import [Link].*;
import [Link];

public class ListaEnOrden

{
public static void main(String [] a)
{
Random r;
int d;
ListaOrdenada lista;
int k;

r = new Random(); // generador de números aleatorios

lista = new ListaOrdenada(); // crea lista vacía
k = [Link](99)+1; // número de elementos
// inserta elementos en la lista
for (; k >= 0; k-- )
{
d = [Link]();
[Link](d);
}
// escribe los elementos de la lista
[Link]("Elementos de la lista ordenada \n");
[Link]();
}
}

EJEMPLO 8.4
public Nodo buscarPosicion(int posicion)
{
Nodo indice;
int i;

if (0 < posicion) // posición ha de ser mayor que 0

return null;
indice = primero;
for (i = 1 ;(i < posicion) && (indice != null); i++)
indice = [Link];
return indice;
}
EJERCICIO 8.3
import [Link];
import [Link].*;
import listaDobleEnlace.*;

class ListaEnRango
{
public static void main(String [] ar) throws IOException
{
Random r;
int d, x1,x2;
final int M = 29; // número de elementos de la lista
final int MX = 999;
BufferedReader entrada = new BufferedReader(
new InputStreamReader([Link]));
ListaDoble listaDb;

r = new Random();
listaDb = new ListaDoble();

for (int j = 1; j <= M ; j++)

{
d = [Link](MX) + 1;
[Link](d);
}

[Link]("Elementos de la lista original");

[Link]();
// rango de valores
[Link]("\nRango que va a contener la lista");
x1 = [Link]([Link]());
x2 = [Link]([Link]());
//
IteradorLista iterador = new IteradorLista(listaDb);
Nodo a;

a = [Link]();
while (a != null)
{
int w;
w = [Link]();
if (!(w >= x1 && w <= x2)) // fuera de rango
[Link](w);
a = [Link]();
}
[Link]("Elementos actuales de la lista");
[Link]();
}
}
EJERCICIO 8.4
package listaCircularPalabra;

class Nodo
{
String dato;
Nodo enlace;
public Nodo (String entrada) {;}
}

public class ListaCircular

{
private Nodo lc;

public ListaCircular(){;}
public ListaCircular insertar(String entrada){;}

public void eliminar(String entrada)

{
Nodo actual;
actual = lc;
while (([Link] != lc) &&
!([Link](entrada)))
{
if ()
actual = [Link];
}
// Enlace de nodo anterior con el siguiente
// si se ha encontrado el nodo.

if ([Link](entrada))
{
Nodo p;
p = [Link]; // Nodo a eliminar
if (lc == [Link]) // Lista con un solo nodo
lc = null;
else
{
if (p == lc)
{
lc = actual; // Se borra el elemento referenciado por lc,
// el nuevo acceso a la lista es el anterior
}
[Link] = [Link];
}
p = null;
}
}

public void borrarLista()

{
Nodo p;
if (lc != null)
{
p = lc;
do {
Nodo t;
t = p;
p = [Link];
t = null; // no es estrictamente necesario
 }while(p != lc);
}
else
[Link]("\n\t Lista vacía.");
lc = null;
}
public void recorrer(){;}

}
/* clase con el método main(). Se escribe un sencillo menu para
elegir operaciones con la lista circular.
*/
import [Link].*;
import listaCircularPalabra.*;
class ListaPalabras
{
public static void main(String [] a) throws IOException
{
String palabra;
ListaCircular listaCp;
int opc;
BufferedReader entrada = new BufferedReader(
new InputStreamReader([Link]));

listaCp = new ListaCircular();

[Link]("\n Entrada de Nombres. Termina con ^Z.\n");

while ((palabra = [Link]())!= null)
{
String nueva;
nueva = new String(palabra);
[Link](nueva);
}

[Link]("\t\tLista circular de palabras");

[Link]();

[Link]("\n\t Opciones para manejar la lista");

do {
[Link]("1. Eliminar una palabra.\n");
[Link]("2. Mostrar la lista completa.\n");
[Link]("3. Salir y eliminar la lista.\n");
do {
opc = [Link]([Link]());
}while (opc<1 || opc>3);

switch (opc) {
case 1: [Link]("Palabra a eliminar: ");
palabra = [Link]();
[Link](palabra);
break;
case 2: [Link]("Palabras en la Lista:\n");
[Link]();
break;
case 3: [Link]("Eliminación de la lista.");
[Link]();
}
}while (opc != 3);
}
}
LISTA ORDENADA

package ListaEnteros;

public class ListaOrdenada extends Lista

{
public ListaOrdenada()
{
super();
}
public ListaOrdenada insertaOrden(int entrada)
{
Nodo nuevo ;
nuevo = new Nodo(entrada);

if (primero == null) // lista vacía

primero = nuevo;
else if (entrada < [Link]())
{
nuevo. setEnlace(primero);
primero = nuevo;
}
else /* búsqueda del nodo anterior a partir del que
se debe insertar */
{
Nodo anterior, p;
anterior = p = primero;

while (([Link]() != null) && (entrada > [Link]()))

{
anterior = p;
p = [Link]();
}

if (entrada > [Link]()) //inserta después del último nodo

anterior = p;
// Se procede al enlace del nuevo nodo
[Link]([Link]());
[Link](nuevo);
}
return this;
}
// métodos a codificar:
public void eliminar (int entrada){ ; }
public Nodo buscarLista(int destino){ ; }

}
LISTA DOBLEMENTE ENLAZADA

package listaDobleEnlace;
public class Nodo
{
int dato;
Nodo adelante;
Nodo atras;
public Nodo(int entrada)
{
dato = entrada;
adelante = atras = null;
}

public int getDato()

{
return dato;
}
public Nodo getEnlace()
{
return adelante;
}
public void setEnlace(Nodo adelante)
{
[Link] = adelante;
}

package listaDobleEnlace;

public class ListaDoble

{
Nodo cabeza;
public ListaDoble()
{
cabeza = null;
}
public ListaDoble insertarCabezaLista(int entrada)
{

Nodo nuevo;

nuevo = new Nodo(entrada);

[Link] = cabeza;
if (cabeza != null )
[Link] = nuevo;
cabeza = nuevo;
return this;
}

public ListaDoble insertaDespues(Nodo anterior, int entrada)

{
Nodo nuevo;

nuevo = new Nodo(entrada);

[Link] = [Link];
if ([Link] !=null)
[Link] = nuevo;
 [Link] = nuevo;
[Link] = anterior;
return this;
}

public void eliminar (int entrada)

{
Nodo actual;
boolean encontrado = false;

actual = cabeza;
// Bucle de búsqueda
while ((actual != null) && (!encontrado))
{
/* la comparación se realiza con el método equals()...,
depende del tipo Elemento */
encontrado = ([Link] == entrada);
if (!encontrado)
actual = [Link];
}
// Enlace de nodo anterior con el siguiente
if (actual != null)
{
//distingue entre nodo cabecera o resto de la lista
if (actual == cabeza)
{
cabeza = [Link];
if ([Link] != null)
[Link] = null;
}
else if ([Link] != null) // No es el último nodo
{
[Link] = [Link];
[Link] = [Link];
}
else // último nodo
[Link] = null;

actual = null;
}
}

public void visualizar()

{
Nodo n;
int k = 0;

n = cabeza;
while (n != null)
{
[Link]([Link] + " ");
n = [Link];
k++;
[Link]( (((k%10 != 0)&& (n!= null)) ? " " : "\n"));
}
}
}
ITERADOR DE LISTA DOBLE

package listaDobleEnlace;

public class IteradorLista

{
Nodo actual;
public IteradorLista(ListaDoble ld)
{
actual = [Link];
}
public Nodo siguiente()
{
Nodo a;
a = actual;
if (actual != null)
{
actual = [Link];
}
return a;
}
}
LISTA GENÉRICA
// Declaración de la clase nodo

package listaGenerica;

public class Nodo

{
Object dato;
Nodo enlace;

public Nodo(Object x)
{
dato = x;
enlace = null;
}
public Nodo(Object x, Nodo n)
{
dato = x;
enlace = n;
}
public Object leerDato()
{
return dato;
}
public Nodo siguiente()
{
return enlace;
}

}
// Declaración de la clase Lista.
package listaGenerica;

public class Lista

{
private Nodo primero;
public Lista()
{
primero = null;
}
public Nodo leerPrimero()
{
return primero;
}
public Lista insertarCabezaLista(Object entrada)
{
Nodo nuevo ;
nuevo = new Nodo(entrada)
[Link] = primero;
primero= nuevo;
return this;
}
public Nodo leerPrimero()
{
return primero;
}
public Lista insertarLista(Nodo anterior, Object entrada)
{
Nodo nuevo;
 nuevo = new Nodo(entrada);
[Link] = [Link]
[Link] = nuevo;
return this;
}

public void eliminar (Object entrada)

{
Nodo actual, anterior;
boolean encontrado;

actual = primero;
anterior = null;
encontrado = false;
// Bucle de búsqueda
while ((actual!= null) && )
{
if ()
{
anterior = actual;
actual = [Link];
}
}

if (actual != null)
{
// Se distingue entre que el nodo sea el cabecera
// o del resto de la lista
if (acual == primero)
{
primero = [Link];
}
else
{
[Link] = [Link]
}
actual = null;
}
}

public Nodo buscarLista(Object destino)

// destino: dato que se busca en la lista.
{
Nodo indice;
for (indice = primero; indice != null; indice = [Link])
if ([Link](destino))
return indice;
return null;
}
public void visualizar()
{
Nodo n;
n = primero;
while (n != null)
{
[Link]([Link] + " ");
n = [Link];
}
}
}
ITERADOR LISTA GENÉRICA
package listaGenerica;

public class ListaIterador

{
private Nodo prm, actual;

public ListaIterador(Lista list)

{
prm = actual = [Link]();
}

public Object siguiente()

{
Object elemento = null;
if (actual != null)
{
elemento = [Link]();
actual = [Link]();
}
return elemento;
}
public void inicIter()
{
actual = prm;
}
}