Prefacio
Una lista vinculada es una estructura de datos básica común. Es una tabla lineal, pero no se almacena secuencialmente en la memoria. Se almacena en forma de cadena. Cada nodo almacena el "puntero" del siguiente nodo. Los datos en Java se dividen en tipos de datos de referencia y tipos de datos básicos. No existe un concepto de punteros en Java, pero para las listas vinculadas, los punteros se refieren a la dirección de los tipos de datos de referencia.
Las listas y matrices vinculadas son estructuras de datos lineales, y su longitud se fija para las matrices. Como son continuos en la memoria, son más adecuados para la búsqueda y el recorrido. Las listas vinculadas no se almacenan secuencialmente en la memoria, pero debido a que están compuestas de "punteros", es más conveniente comparar matrices al insertar y eliminar.
El siguiente código implementa una estructura de datos simple de una lista vinculada descrita en el lenguaje Java a través de clases internas y métodos recursivos. Echemos un vistazo a la introducción detallada.
Definición de estructura de datos de lista vinculada
Primero, echemos un vistazo a la definición de la estructura de datos de la lista vinculada, el código es el siguiente:
clase Nodemanager {Raíz de nodo privado; // Root Node private int centreinDex = 0; // Número de serie de nodo, cada operación comienza desde 0 public void add (int data) {} public void delnode (int data) {} public void print () {} public boolean findNode (int data) {} public boolean UpdateTeNode (int OldData, int NewData) {} // Public Void Insert (int Index) {{{{{{} // Nodo {datos privados int; Nodo privado Siguiente; // Tome el tipo actual como un nodo público de propiedad (int data) {this.data = data; } public void setData (int data) {this.data = data; } public int getData () {return data; } // Agregar nodo public void addNode (int data) {} // Eliminar el nodo public void delnode (int data) {} // emitir todos los nodos public void printNode () {} // Buscar si el nodo existe public boolean findNode (int data) {} // modificar el nodo public boolean ( void insertNode (int index, int data) {}}}Para la definición de listas vinculadas, la clase Nodemanager se utiliza para administrar operaciones de lista vinculada, mientras que el nodo de clase interna del miembro se utiliza para proporcionar datos de lista vinculados y estructura de cadena. Para los usuarios de la clase, no se accede directamente a los datos, por lo que la clase Nodemanager funciona, y el nodo de clase interna proporciona administración de datos real. Por lo tanto, la clase de nodo debe proporcionar métodos reales de operación de datos, y la clase Nodemanager también debe proporcionar un conjunto de métodos para operar listas vinculadas externamente. Por lo tanto, tanto la clase Nodemanager como la clase de nodo proporcionan aparentemente los mismos métodos, pero el significado real no es el mismo.
Verifiquemos el método add () en la clase Nodemanager y la clase de nodo. El código es el siguiente:
public void add (int data) {if (root == null) {root = new nodo (data); } else {root.addnode (datos); }} // Agregar nodo public void addNode (int data) {if (this.next == null) {this.next = new node (data); } else {this.next.addnode (datos); }}El método anterior en el código es el método en la clase Nodemanager, mientras que el siguiente método es el método en la clase de nodo.
Se proporciona una variable de miembro de la raíz en la clase Manager, que se utiliza para administrar el nodo principal de la lista vinculada. Por lo tanto, al agregar un nodo, primero determinará si la raíz está vacía. Si está vacío, la raíz guardará el nodo directamente. Si la raíz no está vacía, se agregará a través del método addNode () en la clase de nodo. La idea de agregar al punto es encontrar el último nodo de la lista vinculada actual y asignar la nueva adición a la siguiente variable miembro que el nodo se asigna al último nodo.
Agregar, eliminar, modificar y verificar la lista vinculada
La misma idea también se da a otras operaciones en listas vinculadas. El código completo para agregar, eliminar, recuperar y salida de listas vinculadas es el siguiente:
clase Nodemanager {Raíz de nodo privado; // Root Node private int centreinDex = 0; // Número de serie del nodo, cada operación comienza desde 0 public void add (int data) {if (root == null) {root = new nodo (data); } else {root.addnode (datos); }} public void delnode (int data) {if (root == null) return; if (root.getData () == data) {nodo tmp = root; root = root.next; tmp = nulo; } else {root.delnode (datos); }} public void print () {if (root! = null) {system.out.print (root.getData () + ""); root.printnode (); System.out.println (); }} public boolean findNode (int data) {if (root == null) return false; if (root.getData () == data) {return true; } else {return root.findNode (datos); }} public boolean UpdateTenode (int if (root.getData () == OldData) {root.setData (newData); devolver verdadero; } else {return root.updatenode (OldData, newData); }} // Insertar public void Insert (int index, int data) {if (index <0) return; CurrentIndex = 0; if (index == currentIndex) {node newNode = new Node (datos); newnode.next = root; root = Newnode; } else {root.insertNode (index, data); }} // Quien sea dueño de los datos, quien proporciona el nodo de clase de método {private int data; Nodo privado Siguiente; // Tome el tipo actual como un nodo público de propiedad (int data) {this.data = data; } public void setData (int data) {this.data = data; } public int getData () {return data; } // Agregar nodo public void addNode (int data) {if (this.next == null) {this.next = new node (data); } else {this.next.addnode (datos); }} // Elimine el nodo public void delnode (int data) {if (this.next! = Null) {if (this.next.getData () == data) {nodo tmp = this.next; this.next = this.next.next; tmp = nulo; } else {this.next.delnode (datos); }}} // emitir todos los nodos public void printnode () {if (this.next! = Null) {system.out.print (this.next.getData () + ""); this.next.printnode (); }} // Encuentre si el nodo existe public boolean findNode (int data) {if (this.next! = Null) {if (this.next.getData () == data) {return true; } else {return this.next.findnode (datos); }} return false; } // Modifique el nodo público boolean updateTenode (int OldData, int newData) {if (this.next! = Null) {if (this.next.getData () == OldData) {this.next.setData (newData); devolver verdadero; } else {return this.next.updatenode (OldData, newData); }} return false; } // Insertar nodo public void InsertNode (int index, int data) {currentIndex ++; if (index == currentIndex) {node newNode = new Node (datos); newnode.next = this.next; this.next = newnode; } else {this.next.insertnode (index, data); }}}}}El anterior es el código completo para la operación básica de la lista vinculada. El siguiente es un código de llamada para la prueba, el código es el siguiente:
public class LinkList {public static void main (string [] args) {nodanager nm = new Nodemanager (); System.out.println ("Dirección de la lista vinculada (agregar 5, 4, 3, 2, 1)"); nm.Add (5); nm.Add (4); nm.Add (3); nm.Add (2); nm.Add (1); nm.print (); System.out.println ("Eliminar la lista vinculada (eliminar 3)"); nm.delnode (3); nm.print (); System.out.println ("Buscando la lista vinculada (encontrar 1)"); System.out.println (nm.findnode (1)); System.out.println ("Lista de enlace (encontrar 10)"); System.out.println (nm.findnode (10)); System.out.println ("Lista de actualización (actualización 1 a 10)"); nm.updatenode (1, 10); nm.print (); System.out.println ("Insertar lista (inserte 20 en la primera posición)"); nm.insert (1, 20); nm.print (); System.out.println ("Insertar lista (inserte 30 en la primera posición)"); nm.insert (1, 20); nm.print (); System.out.println ("Insertar lista (inserte 30 en la posición cero)"); nm.insert (0, 30); nm.print (); }}Compilar y ejecutar el código, el resultado es el siguiente:
He usado mucho conocimiento sobre estructuras de datos en la clase de recopilación en Java. Cuando esté en buenas condiciones, aprenderé el código fuente de la clase de colección Java. ¡Trabajaré duro para ser un programador junior!
Resumir
Lo anterior es todo el contenido de este artículo. Espero que el contenido de este artículo tenga cierto valor de referencia para el estudio o el trabajo de todos. Si tiene alguna pregunta, puede dejar un mensaje para comunicarse. Gracias por su apoyo a Wulin.com.