Lista enlazada de Java
clase Nodo
{
Datos del objeto;
Nodo siguiente // Apunta al siguiente nodo
}
La razón por la que el campo de datos se define como una clase de objeto es que la clase de objeto es una superclase general, y a cualquier objeto de esta clase se le puede asignar un valor, aumentando así la versatilidad del código. Para poder acceder a la lista vinculada, se debe definir un encabezado que contenga un puntero al primer nodo y un puntero al nodo actual. Para agregar un nodo al final de la lista, agregue un puntero al final de la lista y use un campo para representar el tamaño de la lista, de modo que la persona que llama no tenga que recorrer toda la lista cuando quiera obtener el Tamaño de la lista. La siguiente figura muestra un diagrama esquemático de dicha lista vinculada:
Estructura de datos de la lista vinculada
Podemos usar la clase Lista para implementar la estructura de la lista vinculada y usar las variables Head, Cola, Longitud y Puntero para implementarlo Encabezado. Existen ciertas técnicas para almacenar el puntero del nodo actual. El puntero no es un puntero al nodo actual, sino un puntero a su nodo anterior. Cuando su valor está vacío, significa que el nodo actual es el primer nodo. Entonces, ¿por qué hacer esto? Esto se debe a que cuando se elimina el nodo actual, aún es necesario asegurarse de que los nodos restantes formen una lista vinculada. Si el puntero apunta al nodo actual, traerá grandes dificultades a la operación. Entonces, ¿cómo obtener el nodo actual? Definimos un método cursor(), cuyo valor de retorno es un puntero al nodo actual. Class List también define algunos métodos para implementar operaciones básicas de listas vinculadas. Al utilizar estas operaciones básicas, podemos realizar varias operaciones en listas vinculadas. Por ejemplo, el método reset() convertirá el primer nodo en el nodo actual; el método insert(Object d) insertará un nodo antes del nodo actual y lo convertirá en el nodo actual; el método remove() eliminará el nodo actual y; devuelve su contenido y convierte su nodo sucesor en el nodo actual. Si el nodo eliminado es el último nodo, el primer nodo se convertirá en el nodo actual.
El código fuente de la clase de lista vinculada List es el siguiente:
import java.io.*
public class List
/* Usar variables para implementar encabezados*/
private Node Head=null
private Node Tail=null; > Private Node Pointer= null;
private int Longitud=0;
public void deleteAll()
/* Borrar toda la lista enlazada*/
{
Cabeza=null;
Cola=null
Puntero=null
Longitud=0;
}
public void reset()
/*Restablece la lista enlazada para que el primer nodo sea el nodo actual*/
/*El primer nodo es el nodo actual.
{
Pointer=null;
}
public boolean isEmpty()
/*Juzga el lista enlazada ¿Está vacía*/
{
return(Length==0
}
public boolean isEnd());
p>/*Determinar si el nodo actual es el último nodo*/
{
if(Length==0)
lanzar nuevo java. lang.NullPointerException();
else if(Length==1)
return true
else
return(cursor; ()==Cola );
}
}lang.NullPointerException();
más
{
Temperatura de nodo= cursor();
Puntero=temp;
if(temp!=Cola)
return(temp.next.data);
else
throw new java.util.NoSuchElementException();
}
Nodo temp=cursor(); >
Puntero =temp;
if(temp!
}
objeto público currentNode()
/* Devuelve el valor del nodo actual*/
{
Node temp=cursor();
return temp.data; /p>
}
public void insert(Objeto d)
/* Inserta un nodo antes del nodo actual y conviértelo en el nodo actual*/
{
Nodo e=nuevo Nodo(d);
if(Longitud==0)
{
Cola= e;
Cabeza=e
}
De lo contrario
{
Nodo temp=cursor()
e.next=temp;
if(Pointer==null)
Head=e
De lo contrario
Puntero. next=e;
}
Longitud;
}
public int size()
/* Devuelve el tamaño de la lista enlazada*/
{
return (Longitud
}
); public Object remove()
/* Mueve el nodo actual fuera de la lista vinculada y el siguiente nodo se convierte en el nodo actual. Si el nodo eliminado es el último nodo, el primer nodo se convierte en el nodo actual*. /
{
Temp del objeto
if(Length==0)
throw new java.util.NoSuchElementException(); p> else if(Longitud==1)
{
temp=Head.data
eliminarTodo();
else if(Longitud==1)
{
temp=Head.data
eliminarTodo().
De lo contrario
{
Nodo cur=cursor();
temp=cur.data
if(cur; ==Cabeza)
Cabeza=cur.next;
else if(cur==Cola)
{
Puntero.siguiente =null;
Tail=Puntero;
reset();
}
De lo contrario
Puntero. next=cur.next;
Longitud- -
}
Temperatura de retorno
}
cursor de nodo privado()
/* Devuelve un puntero al nodo actual**
{
if(Head==null)
lanzar nueva java.lang.NullPointerException();
else if(Pointer==null)
return Head
else
return Pointer.next;
return Pointer.> }
public static void main(String[] args)
/* Ejemplo de aplicación simple de vinculado lista* /
{
Lista a=nueva Lista ();
for(int i=1; ilt; =10; i )
a.insert(new Integer(Pointer.next))
for(int i=1;ilt;=10;i)
a.insert(new Integer (Pointer .next)) {
System.in.read();
// Garantiza que los usuarios vean los resultados de la ejecución del programa
}
catch(IOException e)
{}
}
}
clase Nodo
/* Definir los nodos que componen la lista enlazada*/
{
Datos del objeto
Nodo siguiente
Nodo; (Objeto d)
{
data=d
next=null;
}
}
}
Los lectores también pueden definir nuevos métodos para operar tablas vinculadas según sea necesario. Una lista doblemente enlazada se puede implementar de manera similar, excepto que la clase del nodo agrega un puntero al nodo anterior.
Esto se puede lograr usando el siguiente código:
class Nodo
{
Datos del objeto
Nodo siguiente ;
Nodo anterior
Nodo(Objeto d)
{
data=d; > Nodo (Objeto d)
{
data=d
siguiente=null
anterior=null; >
}
}
Nodo(Objeto d)
{
datos=d ;
siguiente=nulo
anterior=nulo
}