Este artículo comparte el código relevante para Java para implementar listas vinculadas únicas y listas vinculadas de dos vías para su referencia. El contenido específico es el siguiente
Java implementa una sola lista vinculada:
código de paquete; class nodo {nodo Next; datos int; public nodo (int data) {this.data = data; }} clase LinkList {nodo primero; // Cabeza public LinkList () {this.first = null; } public void addNode (nodo NO) {No.Next = primero; Primero = no; // Agregar en la cabeza} public void DelectNode () {nodo n = first.next; primero = nulo; Primero = n; // Eliminar en la cabeza} // Elimine la posición especificada public int number () {int count = 1; // Vea cuántos elementos hay nodo nd = primero; while (nd.next! = null) {nd = nd.next; contar ++; } recuento de retorno; } public void DelectExact (int n) {// elimina la posición especificada si (n> 1) {int count = 1; Nodo de = primero; while (count <n-1) {de = de.next; contar ++; } de.next = de.next.next; } else primero = first.next; } public void addexact (int n, nodo nd) {if (n> 1) // agregue la posición especificada {int count = 1; Nodo de = primero; while (count <n-1) {de = de.next; contar ++; } nd.next = de.next; de.next = nd; } else primero = first.next; } public int FindNode (int n) {int count = 1; // Encuentre la posición correspondiente a un nodo de número de = primero; while (de.data! = n) {de = de.next; contar ++; if (de == null) {return -1; }} return Count; } public void print () {nodo no = first; // imprima todo while (no! = null) {system.out.println (No.data); No = No.Next; }}} public class TextNode {public static void main (string [] args) {LinkList ll = new LinkList (); ll.addnode (nuevo nodo (12)); ll.addnode (nuevo nodo (15)); ll.addnode (nuevo nodo (18)); ll.addnode (nuevo nodo (19)); ll.addnode (nuevo nodo (20)); /*System.out.println(ll.first.data); ll.delectNode (); System.out.println (ll.first.data);*/ system.out.println (ll.number ()); ll.delectexact (3); ll.Addexact (3, nuevo nodo (100)); System.out.println (ll.number ()); // ll.print (); System.out.println (ll.FindNode (112)); }}Java implementa la lista vinculada de dos vías:
clase pública DoubleLink {public static void main (string [] args) {node2 no = new node2 (5); No.Addleft (nuevo nodo2 (6)); No.addright (nuevo nodo2 (7)); /*no.print (); No.Print2 ();*/ No.AddexAct2 (1, nuevo nodo2 (8)); No.print (); System.out.println ("-------------------"); No.Print2 (); }} class node2 {public nodo2 primero; Nodo público 2 final; nodo público a la izquierda; nodo público2 derecho; int data = 0; public nodo2 (int n) {primero = this; fin = esto; primero.data = n; } // agregue el público vacío desde la cabeza addleft (node2 antes) {first.left = antes; antes. derecho = primero; primero = antes; } // agregue el público vacío de la cola addright (nodo2 después) {end.right = después; After.left = end; final = después; } // inserte el número de public void addexact (int n, nodo2 no) {int count = 0; if (n == 0) {addleft (no); } else {nodo2 f = primero; while (true) {f = f.right; contar ++; if (count == n) {// Este es el cambio en la señalización de los cuatro punteros No.Left = f.left; f.left.right = no; // primero.left = no; No. derecho = f; f.left = no; romper; }}}}} // inserta el número de public void addExact2 (int n, nodo2 no) {int count = 0; if (n == 0) {addright (no); } else {nodo2 f = end; while (true) {f = f.left; contar ++; if (count == n) {No.left = f; No. Right = F.Right; F.Right.left = no; F.Right = no; romper; }}}}} // Positive Traversal public void print () {System.out.println (first.data); while (first.right! = null) {system.out.println (first.right.data); Primero = Primero. } // system.out.println (end.data); } // Reverse Traversal public void print2 () {System.out.println (end.data); while (end.left! = null) {system.out.println (end.left.data); end = end.left; }}}/*Vale la pena señalar que cada vez que se inserta un nuevo objeto, debe prestar atención al cambio de puntero. Primero, la señalización de ambos lados de este nuevo objeto (izquierda y derecha), seguido por la señalización del objeto izquierdo hacia la derecha y la señalización del objeto derecho hacia la izquierda. La señalización de estos cuatro punteros debe ser correcto, de lo contrario puede llevar a la incapacidad de implementar un recorrido positivo o de reverso. *//*Compare listas vinculadas únicas, las listas vinculadas únicas solo se pueden atravesar desde una dirección porque solo hay una cabeza, mientras que una lista vinculada bidireccional tiene una cabeza y una cola. Se puede atravesar desde la * cabeza o desde la cola. Además, debido a que uno de los objetos tiene punteros en dos direcciones, puede obtener el objeto * a la izquierda y el objeto a la derecha. * Pero para listas ligadas, porque solo hay una dirección, solo pueden ir a la izquierda o a la derecha. Al agregar objetos, también puede agregarlos desde el principio o desde el final. * Si una sola lista vinculada necesita agregar dos direcciones, es raro, o no, porque solo tiene punteros a una dirección a la izquierda o a la derecha*, mientras que cada objeto de una lista vinculada bidireccional tiene punteros a dos direcciones, lo que no es más flexible, pero esto también tiene desventajas, porque de esta manera, cada objeto* contendrá dos Pointers, que también consumirán más memoria. * * */Lo anterior se trata de este artículo, espero que sea útil para todos aprender la programación de Java.