Cómo implementar una lista doblemente enlazada en Java
La estructura del punto de enlace:
┌────┬────┬────────┐
│Datos │Down One│Anterior│
└────┴────┴───────┘
Una lista doblemente enlazada no es necesariamente una lista doblemente enlazada (guarde la última referencia A a un punto de enlace), la lista doblemente enlazada es bidireccional cuando se inserta.
Hay dos cadenas: una de principio a fin y otra de principio a fin. El recorrido de eliminación también es bidireccional.
/**
*Lista de doble enlace
*/
Lista de doble enlace de clase pública & lt; / p>
Enlace privado & ltt & gt head; // primer nodo
Enlace privado & ltt & gt rear // puntero de cola
public doublelinkedlist() { }
public T peekHead() {
if (head!= null) {
return head.data
}
return null
}
public boolean isEmpty() {
return head = = null
}
public void insert first(tdata){//Inserte el encabezado del enlace.
Link & ltt & gtnewLink = new link & ltt & gt (data
Si (isEmpty()) {//está vacío, el nuevo nodo se inserta por primera vez; es el nodo de cola.
rear = newLink
} De lo contrario {
head.previous = newLink//El nodo superior del antiguo nodo principal es igual al nuevo nodo.
}
newLink.next = head//El nuevo nodo y los nodos subordinados del antiguo nodo principal
head = newLink//Después de la asignación, el nodos subordinados del nodo principal Un nodo es el antiguo nodo principal y el nodo anterior está vacío.
}
Public void insertLast(T data) {//Insertar al final de la cadena.
Enlace<t>newLink=nuevo enlace<t>(data);
if (isEmpty()) {
head = newLink
}En caso contrario {
rear.next = newLink
}
newLink.previous = rear
rear = newLink/ / Después de la asignación, el nodo superior de el nodo de cola es el antiguo nodo de cola y el nodo inferior está vacío.
}
Public T deleteHead() {//Eliminar el encabezado del enlace.
si (isEmpty()) devuelve nulo
Link & ltt & gttemp = head
head = head.next//Cambia el primer nodo al siguiente nodo .
if (head ! = null) {
head.previous = null
} else {
rearward = null;
head.previous = null
} p>
}
Devolver temp.data
}
Public T deleteRear() {// Elimina el final de la cadena.
si (isEmpty()) devuelve nulo
Enlace<t>temp=rear;
rear=rear.previous;//Cambiar el nodo de cola es el nodo anterior.
if (trasero!= nulo) {
trasero.siguiente = nulo
} más {
cabeza = nulo
}
Devolver temp.data
}
Public T find(T t) {//Buscar de principio a fin.
if (isEmpty()) {
Devolver nulo
}
Enlace<t>find=head;
Y (buscar! = null) {
if (!find.data.equals(t)) {
buscar = find.next
}else{
romper;
}
}
if (find == null) {
Devolver null
}
Devolver find.data
}
Eliminar T pública (T t) {
if (isEmpty ()) {
Devolver nulo
}
Enlace & ltt & gt current = head
Y (!current.data; .equals(t)) {
actual = actual.siguiente
if (actual == nulo) {
Devolver nulo
}
}
if (actual == cabeza) {
cabeza = cabeza.siguiente
if (cabeza! = nulo) {
head.previous = null
}
} else if (actual == rear) {
rear=rear.next ;
if (trasero!= nulo) {
trasero.next = nulo
}
}else {
//Nodo intermedio no terminal, elimine el actual.
actual .anterior = actual .
actual .siguiente = actual . current.data
}
Insertor booleano público (tkey, tdata){//Insertar después de la clave, la clave no devuelve falso.
if (isEmpty()) {
Devuelve falso
}
Enlace & ltt & gt current = head
Y (!current.data.equals(key)) {
current = current.next
if (current == null) {
Devuelve falso
}
}
Enlace & ltt & gtnewLink = nuevo enlace & ltt & gt(datos)
if; (actual == trasero) {
trasero = nuevoEnlace
}else {
nuevo enlace. siguiente = actual siguiente;
actual . siguiente . anterior = nuevo enlace;
}
current.next = newLink
newLink.previous = actual
Devuelve verdadero
}
Lista de visualización de Public Void 4 Head(){//Atravesar desde el principio.
system . out . println(" Lista(primero-& gt; último):));
Enlace & ltt & gt current = head;
Y (actual! = nulo) {
actual enlace de visualización();
actual = actual.siguiente
}
}
Lista de visualización de vacíos públicos 4 rear(){//Atravesar desde el final.
sistema . out . println(" Lista(último-> primero):);
Enlace<t>current=último;
Y (actual! = nulo) {
actual . mostrar enlace();
actual = actual.anterior
}
}
Enlace de clase & ltt & gt{//Punto de enlace
Datos de prueba; //Campo de datos
Enlace & ltt & gtNext //Puntero sucesor, campo de cadena de nodos
Enlace & ltt & gt anterior; //Puntero precursor, campo de cadena de nodos
Enlace (datos de prueba) {
datos = datos
}
void displayLink() {
System.out.println("los datos son"+datos . tostring());
p>
}
}
Public static void main(String[] args) {
DoublyLinkedList & lt integer& gtlist = new DoublyLinkedList & lt Integer>();
lista .insertar último(1);
lista .insertar primero(2);
lista . lista .insertar primero(4);
lista .insertar último(5);
lista mostrar lista 4 cabeza(); lista . eliminar cabeza();
sistema . println(" eliminar cabeza:"+eliminar cabeza);
lista de visualización 4 cabeza();
entero eliminar trasero = lista. eliminar trasero();
sistema fuera. println(" eliminar trasero:"+eliminar trasero);
lista de visualización 4. ();
sistema . println(" buscar:"+lista . buscar(6));
sistema salir . (3));
System.out.println("Eliminar búsqueda: "+list . eliminar(6));
System.out .println("Eliminar búsqueda:" +lista .eliminar(1));
lista 4 cabeza(); out.println ("-insert-" después de especificar la clave);
list.insertAfter(2, 8);
list.insertAfter(2, 9); >
list.insertAfter(9, 10);
lista mostrar lista 4 cabeza();
}
}
.