A Java, el ListNode és una estructura de dades crucial que s'utilitza per implementar llistes enllaçades de manera eficient. Les llistes enllaçades són estructures de dades dinàmiques que consisteixen en nodes, on cada node conté un valor i una referència al següent node de la llista. Aquest article pretén oferir una visió general completa de ListNode a Java, que cobreix les seves característiques, avantatges i com utilitzar-lo de manera eficaç.

char a cadena

Què és un ListNode?

Un ListNode representa un únic node en una llista enllaçada. Normalment conté dos components principals: el valor o les dades emmagatzemades al node i una referència (o enllaç) al següent node de la llista. En connectar aquests nodes, podem crear una estructura de dades flexible i eficient capaç de gestionar diverses operacions.

Definició d'un ListNode a Java:

A Java, un ListNode sol implementar-se com una classe amb dues variables d'instància: un camp de dades per emmagatzemar el valor i un camp següent per fer referència al següent node. Aquí teniu un exemple d'una classe ListNode simple:

 public class ListNode { int val; ListNode next; public ListNode(int val) { this.val = val; } } 

Treballant amb ListNode:

Creació d'una llista enllaçada:

Per crear una llista enllaçada, instanciem un objecte ListNode per a cada node i establim les connexions entre ells. Aquí teniu un exemple:

 ListNode node1 = new ListNode(10); ListNode node2 = new ListNode(20); ListNode node3 = new ListNode(30); node1.next = node2; node2.next = node3; 

Travessant una llista enllaçada:

Per iterar sobre una llista enllaçada, comencem des del node principal (el primer node de la llista) i seguim les següents referències fins a arribar al final (on la referència següent és nul·la). Aquí teniu un exemple de recórrer la llista anterior:

 ListNode current = node1; while (current != null) { System.out.println(current.val); current = current.next; } 

Afegir i eliminar nodes:

ListNode ens permet afegir i eliminar nodes en diferents posicions de la llista enllaçada. Ajustant les següents referències, podem inserir o eliminar nodes de manera eficient. Aquestes operacions són útils per a estructures de dades dinàmiques que requereixen modificacions freqüents.

Operacions addicionals:

ListNode admet altres operacions, com ara cercar un valor específic, trobar la longitud de la llista enllaçada i realitzar diverses manipulacions a la llista, com ara invertir o ordenar.

Avantatges de ListNode i LinkedLists:

Mida dinàmica:Les llistes enllaçades poden créixer o reduir-se de forma dinàmica a mesura que s'afegeixen o s'eliminen elements, a diferència de les matrius de mida fixa.Insercions i supressions eficients:ListNode permet insercions i supressions eficients a qualsevol posició de la llista, proporcionant flexibilitat en la gestió de dades.Eficiència de memòria:Les llistes enllaçades assignen memòria de manera dinàmica, utilitzant només la quantitat necessària per a cada node, fent-les adequades per a conjunts de dades grans o variables.Versatilitat:Les llistes enllaçades es poden enllaçar individualment (cada node apunta al següent) o doblement (cada node apunta al següent i a l'anterior), oferint diferents compensacions entre l'ús de la memòria i la funcionalitat.

L'estructura de dades ListNode a Java proporciona una base potent per implementar llistes enllaçades. Mitjançant l'ús de ListNode i les seves operacions associades, els desenvolupadors poden gestionar de manera eficient les dades dinàmiques, realitzar manipulacions complexes i crear estructures de dades versàtils. Entendre i dominar el concepte ListNode millorarà molt la vostra capacitat per resoldre problemes i dissenyar algorismes eficients en programació Java.

Aquí hi ha un exemple de programa Java que mostra l'estructura de dades ListNode i realitza operacions bàsiques en una llista enllaçada:

LinkedListExample.java

 class ListNode { int val; ListNode next; public ListNode(int val) { this.val = val; } } public class LinkedListExample { public static void main(String[] args) { // Creating a linked list: 10 -> 20 -> 30 ListNode node1 = new ListNode(10); ListNode node2 = new ListNode(20); ListNode node3 = new ListNode(30); node1.next = node2; node2.next = node3; // Traversing the linked list and printing the values System.out.println('Linked List:'); ListNode current = node1; while (current != null) { System.out.println(current.val); current = current.next; } // Output: 10 20 30 // Adding a new node: 15 -> 20 -> 30 ListNode newNode = new ListNode(15); newNode.next = node2; node1.next = newNode; // Traversing the updated linked list System.out.println('Updated Linked List:'); current = node1; while (current != null) { System.out.println(current.val); current = current.next; } // Output: 10 15 20 30 // Removing a node: 10 -> 15 -> 30 node1.next = newNode.next; // Traversing the modified linked list System.out.println('Modified Linked List:'); current = node1; while (current != null) { System.out.println(current.val); current = current.next; } // Output: 10 20 30 } } 

Sortida:

 Linked List: 10 20 30 Updated Linked List: 10 15 20 30 Modified Linked List: 10 20 30