Home-theater-designers
Une structure de données utilise différentes méthodes prédéfinies pour stocker, récupérer et supprimer des données, ce qui aboutit à la création de programmes efficaces. Une liste chaînée est une structure de données populaire, qui consiste en une liste de nœuds connectés (ou liés).
Mais comment créer une liste chaînée en Java ? Nous allons jeter un coup d'oeil.
Comment fonctionne une liste chaînée ?
Chaque liste chaînée commence par un nœud spécial souvent appelé « tête », qui a la responsabilité de pointer vers le début de la liste à tout moment. La tête est importante car chaque nœud d'une liste chaînée n'a pas besoin de suivre physiquement son successeur (ce qui signifie qu'un prédécesseur et un successeur n'ont pas besoin d'être physiquement adjacents).
Comme toute structure de données, la liste chaînée facilite la création, la récupération, l'insertion et la destruction grâce à un ensemble de fonctions prédéfinies qui peuvent être utilisées par n'importe quel développeur.
Créer une liste chaînée en Java
Un programme Java conçu pour créer et manipuler des listes chaînées aura trois sections distinctes ; la classe de nœud, la classe de liste chaînée et le pilote. Bien que ces trois sections puissent être combinées dans un seul fichier, il existe un principe de conception en informatique connu sous le nom de « séparation des préoccupations » que chaque développeur devrait connaître.
Le principe de séparation des préoccupations dicte que chaque section du code qui traite d'une préoccupation spécifique doit être séparée. Ce principe vous aidera à créer un code plus propre (plus lisible) et est idéal pour créer des structures de données.
La première étape de la création d'une liste chaînée en Java consiste à créer une classe de nœuds. Une classe de nœuds doit avoir deux attributs ; l'un des attributs représentera la portion de données du nœud, tandis que l'autre attribut représentera la portion liée. Une classe de nœud doit également avoir un constructeur, des getters et des setters.
En rapport: Apprenez à créer des classes en Java
Les getters et setters permettront à d'autres classes (telles que la classe de liste chaînée) d'accéder aux différents nœuds de la liste chaînée.
Exemple de classe de nœud
Vous trouverez ci-dessous un exemple de classe de nœuds pour vous donner une idée de ce que nous voulons dire :
public class Node {
private int Data;
private Node NextNode;
//constructor
public Node() {
Data = 0;
NextNode = null;
}
//getters and setters
public int getData() {
return Data;
}
public void setData(int data) {
Data = data;
}
public Node getNextNode() {
return NextNode;
}
public void setNextNode(Node nextNode) {
NextNode = nextNode;
}
}Dans cet exemple, l'attribut data stockera des valeurs entières. Maintenant que vous avez la classe de nœuds, il est temps de passer à la liste chaînée.
Exemple de liste chaînée
Vous trouverez ci-dessous un exemple de liste chaînée en Java.
public class LinkedList {
private Node Head;
//constructor
public LinkedList() {
Head = null;
}
}
Le code ci-dessus créera une classe de liste chaînée, cependant, sans ses diverses opérations, la classe peut être considérée comme l'équivalent d'un shell vide. La structure de données de la liste chaînée comporte plusieurs opérations qui peuvent être utilisées pour la remplir :
- Insertion à l'avant.
- Insérez au milieu.
- Insertion à l'arrière.
En rapport: Comment créer des structures de données avec des classes JavaScript ES6
La collection de listes chaînées de méthodes d'insertion est l'une des raisons pour lesquelles un développeur peut choisir d'utiliser cette structure de données plutôt qu'une autre structure de données telle que des piles (qui n'autorise l'insertion et la suppression que par le haut).
Utilisation de la méthode d'insertion sur le devant
La méthode d'insertion au début, comme son nom l'indique, insère de nouvelles données (ou de nouveaux nœuds) au début de la liste chaînée.
Exemple de méthode d'insertion à l'avant
Vous trouverez ci-dessous un exemple de la façon dont vous insérez de nouvelles données au début de votre liste.
//insert node at front method
public void insertAtFront(int key) {
//create a new node using the node class
Node Temp = new Node();
//check if the Temp node was successfully created
//assign the data that was provides by the user to it
if(Temp != null) {
Temp.setData(key);
Temp.setNextNode(null);
//check if the head of the linked list is empty
//assign the node that was just created to the head position
if(Head == null) {
Head = Temp;
}
//if a node is already at the head position
//add the new node to it and set it as the head
else {
Temp.setNextNode(Head);
Head = Temp;
}
}
}
Les insérerAvant La méthode de l'exemple ci-dessus permet à un utilisateur d'ajouter de nouveaux nœuds à une liste chaînée donnée.
Exemple d'application de l'insert à l'avant
Vous trouverez ci-dessous un exemple de la façon dont vous appliqueriez l'insert à l'avant.
public class Driver {
//executes the program
public static void main(String[] args) {
//create a new linked list called List
LinkedList List = new LinkedList();
//add each value to the front of the linked list as a new node
List.insertAtFront(10);
List.insertAtFront(8);
List.insertAtFront(6);
List.insertAtFront(4);
List.insertAtFront(2);
}
}
Les Conducteur class (qui est le nom qui est souvent attribué à la classe exécutable en Java), utilise la classe LinkedList pour créer une liste chaînée de cinq nombres pairs. En regardant le code ci-dessus, il devrait être facile de voir que le nombre « 2 » est en tête de liste dans la liste chaînée. Mais comment pouvez-vous confirmer cela?
changer où iTunes sauvegarde l'iphone
Utilisation de la méthode Afficher tous les nœuds
La méthode d'affichage de tous les nœuds est une méthode de liste chaînée essentielle. Sans cela, un développeur ne pourra pas voir les nœuds dans une liste chaînée. Il parcourt la liste chaînée (à partir de la tête) en imprimant les données stockées dans chaque nœud qui forme la liste.
Exemple de méthode Afficher tous les nœuds
Vous trouverez ci-dessous un exemple d'utilisation de la méthode d'affichage de toutes les notes en Java.
//display all nodes method
public void displayAllNodes() {
//create a new node call Temp and assign it to the head of the linked list
//if the head has a null value then the linked list is empty
Node Temp = Head;
if (Head == null){
System.out.println('The list is empty.');
return;
}
System.out.println('The List:');
while(Temp != null) {
//print the data in each node to the console(starting from the head)
System.out.print(Temp.getData() + ' ');
Temp = Temp.getNextNode();
}
}Maintenant que le displayAllNodes méthode a été ajoutée à la Liste Liée class, vous pouvez afficher la liste chaînée en ajoutant une seule ligne de code à la classe du pilote.
Utilisation de l'exemple de méthode Afficher tous les nœuds
Ci-dessous, vous verrez comment vous utiliseriez la méthode d'affichage de tous les nœuds.
//print the nodes in a linked list
List.displayAllNodes(); L'exécution de la ligne de code ci-dessus produira la sortie suivante dans la console :
La liste:
2 4 6 8 10Utilisation de la méthode de recherche de nœud
Il y aura des cas où un utilisateur voudra trouver un nœud spécifique dans une liste chaînée.
Par exemple, il ne serait pas pratique pour une banque qui compte des millions de clients d'imprimer tous les clients dans sa base de données alors qu'elle n'a besoin que de voir les détails d'un client spécifique.
Par conséquent, au lieu d'utiliser le displayAllNodes méthode, une méthode plus efficace consiste à trouver le nœud unique contenant les données requises. C'est pourquoi la recherche d'une méthode à nœud unique est importante dans la structure de données de liste chaînée.
Exemple de méthode de recherche de nœud
Vous trouverez ci-dessous un exemple d'utilisation de la méthode find node.
//search for a single node using a key
public boolean findNode(int key) {
//create a new node and place it at the head of the linked list
Node Temp = Head;
//while the current node is not empty
//check if its data matches the key provided by the user
while (Temp != null) {
if (Temp.getData() == key) {
System.out.println('The node is in the list');
return true;
}
//move to the next node
Temp = Temp.getNextNode();
}
//if the key was not found in the linked list
System.out.println('The node is not in the list');
return false;
}Avec le displayAllNodes méthode, vous avez confirmé que la Liste Liée contient 5 nombres pairs de 2 à 10. Le findNode L'exemple ci-dessus peut confirmer si l'un de ces nombres pairs est le chiffre 4 en appelant simplement la méthode dans la classe du pilote et en fournissant le nombre en tant que paramètre.
Utilisation de l'exemple de méthode Find Node
Vous trouverez ci-dessous un exemple de la façon dont vous utiliseriez la méthode find node dans la pratique.
//check if a node is in the linked list
List.findNode(4);
Le code ci-dessus produira la sortie suivante dans la console :
The node is in the listUtilisation de la méthode Supprimer un nœud
En utilisant le même exemple bancaire que ci-dessus, un client de la base de données de la banque peut souhaiter fermer son compte. C'est là que la méthode de suppression d'un nœud sera utile. C'est la méthode de liste chaînée la plus complexe.
La méthode Supprimer un nœud recherche un nœud donné, supprime ce nœud et lie le nœud précédent à celui qui suit le nœud qui a été supprimé.
Exemple de suppression d'une méthode de nœud
Vous trouverez ci-dessous un exemple de la méthode de suppression d'un nœud.
public void findAndDelete(int key) {
Node Temp = Head;
Node prev = null;
//check if the head node holds the data
//and delete it
if (Temp != null && Temp.getData() == key) {
Head = Temp.getNextNode();
return;
}
//search the other nodes in the list
//and delete it
while (Temp != null) {
if (Temp.getNextNode().getData() == key ) {
prev = Temp.getNextNode().getNextNode();
Temp.setNextNode(prev);
return;
}
Temp = Temp.getNextNode();
}
} Utilisation de l'exemple de méthode Supprimer un nœud
Vous trouverez ci-dessous un exemple d'utilisation de la méthode de suppression d'un nœud dans la pratique.
films gratuits à télécharger et à regarder hors ligne
//delete the node that holds the data 4
List.findAndDelete(4);
//print all nodes in the linked list
List.displayAllNodes();L'utilisation des deux lignes de code ci-dessus dans la classe Driver préexistante produira la sortie suivante dans la console :
The List:
2 6 8 10Vous pouvez maintenant créer des listes liées en Java
Si vous êtes arrivé à la fin de cet article de tutoriel, vous aurez appris :
- Comment créer une classe de nœuds.
- Comment créer une classe de liste chaînée.
- Comment remplir une classe de liste chaînée avec ses méthodes prédéfinies.
- Comment créer une classe de pilotes et utiliser les différentes méthodes de liste chaînée pour obtenir le résultat souhaité.
Une liste chaînée n'est qu'une des nombreuses structures de données que vous pouvez utiliser pour stocker, récupérer et supprimer des données. Puisque vous avez tout ce dont vous avez besoin pour commencer, pourquoi ne pas essayer ces exemples par vous-même en Java ?
Partager Partager Tweeter E-mail Comment créer et effectuer des opérations sur des tableaux en JavaApprendre Java ? Laissez les baies gérer vos données en toute simplicité.
Lire la suite Rubriques connexes- La programmation
- Java
- La programmation
- Conseils de codage
Kadeisha Kean est un développeur de logiciels Full-Stack et un rédacteur technique/technologique. Elle a la capacité distincte de simplifier certains des concepts technologiques les plus complexes; produire du matériel qui peut être facilement compris par tout novice en technologie. Elle est passionnée par l'écriture, le développement de logiciels intéressants et les voyages à travers le monde (à travers des documentaires).
Plus de Kadeisha KeanAbonnez-vous à notre newsletter
Rejoignez notre newsletter pour des conseils techniques, des critiques, des ebooks gratuits et des offres exclusives !
Cliquez ici pour vous abonner