Créer une classe LinkedList à partir de zéro
Nous avons reçu pour mission de créer une LinkedList à partir de rien, et aucune lecture n’est donnée pour nous guider dans cette tâche à l’origine du transfert. De plus, tout ce qui est en ligne semble simplement utiliser les méthodes et tout le matériel LinkedList intégré de Java. Quoi qu'il en soit, les listes chaînées sont parfaitement logiques lorsque vous utilisez les éléments par défaut de Java, mais les créer à partir de rien n'a aucun sens. Disons que j'ai
public class LinkedList {
private LinkedList next;
private final String Word;
// constructor
public LinkedList(String Word, LinkedList next) {
this.Word = Word;
this.next = next;
}
Et comme par magie, nous avons une liste chaînée. Que se passe-t-il? Comment ai-je créé une liste chaînée comme celle-ci? Comment cela marche-t-il? Je suis censé écrire une méthode append qui ajoute un paramètre donné String Word À la fin de this linkedlist. J'ai essayé de regarder la méthode intégrée addLast pour la classe intégrée Java linkedlist, mais cela ne m'aide pas, car je ne comprends vraiment pas ce qui se passe. Quelqu'un se soucie de m'aider :)
Si vous construisez réellement un système réel, alors oui, vous utiliserez généralement les éléments de la bibliothèque standard si ce dont vous avez besoin est disponible. Cela dit, ne considérez pas cela comme un exercice inutile. Il est bon de comprendre comment les choses fonctionnent et la compréhension des listes chaînées est une étape importante vers la compréhension de structures de données plus complexes, dont beaucoup n'existent pas dans les bibliothèques standard.
Il existe certaines différences entre la manière dont vous créez une liste chaînée et la manière dont l'API de collections Java) le fait. L'API Collections tente de respecter une interface plus complexe. L'API de collections liée. La liste est également une liste doublement chaînée, tandis que vous construisez une liste chaînée uniquement.
Avec votre classe LinkedList, une instance sera toujours une liste d'au moins un élément. Avec ce type de configuration, vous utiliseriez null lorsque vous avez besoin d’une liste vide.
Pensez à next comme étant "le reste de la liste". En fait, de nombreuses implémentations similaires utilisent le nom "tail" au lieu de "next".
Voici un diagramme d'un LinkedList contenant 3 éléments:
Notez que c'est un objet LinkedList pointant vers un mot ("Hello") et une liste de 2 éléments. La liste de 2 éléments a un mot ("pile") et une liste de 1 élément. Cette liste de 1 élément a un mot ("débordement") et une liste vide (null). Ainsi, vous pouvez traiter next comme une autre liste qui se trouve être plus courte d’un élément.
Vous voudrez peut-être ajouter un autre constructeur qui prend simplement une chaîne et qui est placé à côté de null. Ce serait pour créer une liste à 1 élément.
Pour ajouter, vous vérifiez si next est null. Si c'est le cas, créez une nouvelle liste d'un élément et affectez-y next.
next = new LinkedList(Word);
Si next n'est pas null, alors ajoutez plutôt next.
next.append(Word);
C'est l'approche récursive, qui représente le moins de code possible. Vous pouvez en faire une solution itérative qui serait plus efficace en Java.*et ne risquerait pas un débordement de pile avec de très longues listes, mais je suppose que le niveau de complexité n'est pas nécessaire pour votre tâche.
* Certaines langues ont l’élimination des appels de fin, qui est une optimisation qui permet à l’implémentation de convertir les "appels de fin" (un appel vers une autre fonction à la toute dernière étape avant de retourner) en (effectivement) un "goto". Cela évite complètement l'utilisation de la pile, ce qui le rend plus sûr (vous ne pouvez pas la saturer si vous n'utilisez pas la pile) et généralement plus efficace. Scheme est probablement l'exemple le plus connu d'une langue dotée de cette fonctionnalité.
Ce que vous avez codé n’est pas un LinkedList , du moins pas un que je reconnaisse. Pour cette affectation, vous voulez créer deux classes:
LinkNode
LinkedList
Un LinkNode possède un champ membre pour les données qu'il contient et une référence de LinkNode au prochain LinkNode dans le LinkedList. Oui, c'est une structure de données auto-référentielle. Un LinkedList a juste une référence spéciale LinkNode qui fait référence au premier élément de la liste.
Lorsque vous ajoutez un élément dans le LinkedList, vous parcourez tous les LinkNode's jusqu'à ce que vous atteigniez le dernier. Cette LinkNode's next devrait être nul. Vous construisez ensuite un nouveau LinkNode ici, définissez sa valeur et ajoutez-le au fichier LinkedList.
public class LinkNode {
String data;
LinkNode next;
public LinkNode(String item) {
data = item;
}
}
public class LinkedList {
LinkNode head;
public LinkedList(String item) {
head = new LinkNode(item);
}
public void add(String item) {
//pseudo code: while next isn't null, walk the list
//once you reach the end, create a new LinkNode and add the item to it. Then
//set the last LinkNode's next to this new LinkNode
}
}
Que diriez-vous d'une implémentation entièrement fonctionnelle d'une liste chaînée non récursive?
J'ai créé cela pour mes algorithmes que je classe comme un tremplin pour acquérir une meilleure compréhension avant de passer à l'écriture d'une classe de file d'attente doublement liée pour une affectation.
Voici le code:
import Java.util.Iterator;
import Java.util.NoSuchElementException;
public class LinkedList<T> implements Iterable<T> {
private Node first;
private Node last;
private int N;
public LinkedList() {
first = null;
last = null;
N = 0;
}
public void add(T item) {
if (item == null) { throw new NullPointerException("The first argument for addLast() is null."); }
if (!isEmpty()) {
Node prev = last;
last = new Node(item, null);
prev.next = last;
}
else {
last = new Node(item, null);
first = last;
}
N++;
}
public boolean remove(T item) {
if (isEmpty()) { throw new IllegalStateException("Cannot remove() from and empty list."); }
boolean result = false;
Node prev = first;
Node curr = first;
while (curr.next != null || curr == last) {
if (curr.data.equals(item)) {
// remove the last remaining element
if (N == 1) { first = null; last = null; }
// remove first element
else if (curr.equals(first)) { first = first.next; }
// remove last element
else if (curr.equals(last)) { last = prev; last.next = null; }
// remove element
else { prev.next = curr.next; }
N--;
result = true;
break;
}
prev = curr;
curr = prev.next;
}
return result;
}
public int size() {
return N;
}
public boolean isEmpty() {
return N == 0;
}
private class Node {
private T data;
private Node next;
public Node(T data, Node next) {
this.data = data;
this.next = next;
}
}
public Iterator<T> iterator() { return new LinkedListIterator(); }
private class LinkedListIterator implements Iterator<T> {
private Node current = first;
public T next() {
if (!hasNext()) { throw new NoSuchElementException(); }
T item = current.data;
current = current.next;
return item;
}
public boolean hasNext() { return current != null; }
public void remove() { throw new UnsupportedOperationException(); }
}
@Override public String toString() {
StringBuilder s = new StringBuilder();
for (T item : this)
s.append(item + " ");
return s.toString();
}
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
while(!StdIn.isEmpty()) {
String input = StdIn.readString();
if (input.equals("print")) { StdOut.println(list.toString()); continue; }
if (input.charAt(0) == ('+')) { list.add(input.substring(1)); continue; }
if (input.charAt(0) == ('-')) { list.remove(input.substring(1)); continue; }
break;
}
}
}
Note: C'est une implémentation assez basique d'une liste simple-liée. Le type 'T' est un espace réservé de type générique. Fondamentalement, cette liste liée doit fonctionner avec tout type héritant de Object. Si vous l'utilisez pour des types primitifs, veillez à utiliser les équivalents de classe nullable (ex "Integer" pour le type "int"). La dernière variable n'est pas vraiment nécessaire, sauf qu'elle raccourcit les insertions à O(1) temps. Les suppressions sont lentes car elles fonctionnent dans O(N) = time mais cela vous permet de supprimer la première occurrence d’une valeur dans la liste.
Si vous le souhaitez, vous pouvez également envisager de mettre en œuvre:
- addFirst () - ajoute un nouvel élément au début de la LinkedList
- removeFirst () - supprime le premier élément de la LinkedList
- removeLast () - supprime le dernier élément de la LinkedList
- addAll () - ajoute une liste/un tableau d'éléments à la liste LinkedList
- removeAll () - supprime une liste/un tableau d'éléments de la liste LinkedList
- contains () - vérifie si la LinkedList contient un élément
- contains () - efface tous les éléments de la liste liée
Honnêtement, quelques lignes de code suffisent pour en faire une liste doublement chaînée. La principale différence entre cette liste et une liste doublement chaînée est que les instances Node) d'une liste doublement chaînée nécessitent une référence supplémentaire pointant vers l'élément précédent de la liste.
L'avantage de cette implémentation par rapport à une implémentation récursive est qu'elle est plus rapide et que vous n'avez pas à craindre d'inonder la pile lorsque vous parcourez de grandes listes.
Il y a 3 commandes pour tester ceci dans le débogueur/console:
- Préfixer une valeur par un '+' l'ajoutera à la liste.
- Le préfixe avec un '-' supprimera la première occurrence de la liste.
- En tapant "print", vous imprimez la liste avec les valeurs séparées par des espaces.
Si vous n'avez jamais vu comment fonctionne l'un de ces éléments, je vous suggère de procéder comme suit dans le débogueur:
- add () - pointe un nouveau nœud sur la fin ou initialise les première/dernière valeurs si la liste est vide
- remove () - parcourt la liste du début à la fin. S'il trouve une correspondance, il supprime cet élément et connecte les liens rompus entre les liens précédent et suivant de la chaîne. Des exceptions spéciales sont ajoutées lorsqu'il n'y a pas de lien précédent ou suivant.
- toString () - utilise l'itérateur foreach pour parcourir simplement la chaîne de liste du début à la fin.
Bien qu'il existe des approches meilleures et plus efficaces pour les listes telles que les listes de tableaux, la compréhension du mode de navigation de l'application via les références/pointeurs est essentielle pour comprendre combien de structures de données de niveau supérieur fonctionnent.
Astuce 1: lisez la description des listes chaînées sur http://en.wikipedia.org/wiki/Linked_list
Astuce 2: l'implémentation de Java de LinkedList est une liste à double liaison. La vôtre est une liste à lien unique. Les algorithmes ne s'appliquent pas directement.
Également:
... mais créer [une classe de liste chaînée] à partir de zéro n'a aucun sens.
Cela dépend du résultat requis du travail. Si l'objectif est de produire un code répondant à certaines exigences fonctionnelles/non fonctionnelles, vous avez raison. Si l'objectif réel est pour vous apprendre comment programmer/concevoir Les API/implémentent des structures de données non triviales, l’utilité du produit final n’est donc pratiquement pas pertinente.
Et comme par magie, nous avons une liste chaînée
Ce que vous avez réellement est un type de données ouvert, qui pourrait être utilisé pour construire une liste (en quelque sorte). Mais ce n'est pas ce que votre professeur veut. Et cela ne serait certainement pas considéré comme une abstraction de liste utile . Une abstraction utile comprendrait:
méthodes pour faire les choses que les programmeurs ne veulent pas avoir à répéter encore et encore, et
une couche d'abstraction qui empêche les programmeurs de "rompre" la liste; par exemple. en créant accidentellement un cycle ou en assemblant accidentellement une sous-liste dans deux listes pour créer un arbre inversé.
Bien sûr, une liste chaînée est un peu déroutant pour la programmation de n00bs, la tentation est plutôt de la regarder comme une poupée russe, car c’est ce qu’il semble être, un objet LinkedList dans un objet LinkedList. Mais c'est une touche difficile à visualiser, regardez-le plutôt comme un ordinateur.
LinkedList = Data + Next Member
Où c'est le dernier membre de la liste si next est NULL
Donc, une LinkedList de 5 membres serait:
LinkedList (Data1, LinkedList (Data2, LinkedList (Data3, LinkedList (Data4, LinkedList (Data5, NULL)))))
Mais vous pouvez y penser simplement:
Data1 -> Data2 -> Data3 -> Data4 -> Data5 -> NULL
Alors, comment pouvons-nous trouver la fin de ceci? Eh bien, nous savons que la valeur NULL est la fin, alors:
public void append(LinkedList myNextNode) {
LinkedList current = this; //Make a variable to store a pointer to this LinkedList
while (current.next != NULL) { //While we're not at the last node of the LinkedList
current = current.next; //Go further down the rabbit hole.
}
current.next = myNextNode; //Now we're at the end, so simply replace the NULL with another Linked List!
return; //and we're done!
}
Ce code est très simple bien sûr, et il sera infiniment en boucle si vous lui alimentez une liste chaînée de liens circulaires! Mais c'est l'essentiel.
Programme de liste chaînée avec les fonctionnalités suivantes
1 Insert At Start
2 Insert At End
3 Insert At any Position
4 Delete At any Position
5 Display
6 Get Size
7 Empty Status
8 Replace data at given postion
9 Search Element by position
10 Delete a Node by Given Data
11 Search Element Iteratively
12 Search Element Recursively
package com.elegant.ds.linkedlist.practice;
import Java.util.Scanner;
class Node {
Node link = null;
int data = 0;
public Node() {
link = null;
data = 0;
}
public Node(int data, Node link) {
this.data = data;
this.link = null;
}
public Node getLink() {
return link;
}
public void setLink(Node link) {
this.link = link;
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
}
class SinglyLinkedListImpl {
Node start = null;
Node end = null;
int size = 0;
public SinglyLinkedListImpl() {
start = null;
end = null;
size = 0;
}
public void insertAtStart(int data) {
Node nptr = new Node(data, null);
if (start == null) {
start = nptr;
end = start;
} else {
nptr.setLink(start);
start = nptr;
}
size++;
}
public void insertAtEnd(int data) {
Node nptr = new Node(data, null);
if (start == null) {
start = nptr;
end = nptr;
} else {
end.setLink(nptr);
end = nptr;
}
size++;
}
public void insertAtPosition(int position, int data) {
Node nptr = new Node(data, null);
Node ptr = start;
position = position - 1;
for (int i = 1; i < size; i++) {
if (i == position) {
Node temp = ptr.getLink();
ptr.setLink(nptr);
nptr.setLink(temp);
break;
}
ptr = ptr.getLink();
}
size++;
}
public void repleaceDataAtPosition(int position, int data) {
if (start == null) {
System.out.println("Empty!");
return;
}
Node ptr = start;
for (int i = 1; i < size; i++) {
if (i == position) {
ptr.setData(data);
}
ptr = ptr.getLink();
}
}
public void deleteAtPosition(int position) {
if (start == null) {
System.out.println("Empty!");
return;
}
if (position == size) {
Node startPtr = start;
Node endPtr = start;
while (startPtr != null) {
endPtr = startPtr;
startPtr = startPtr.getLink();
}
end = endPtr;
end.setLink(null);
size--;
return;
}
Node ptr = start;
position = position - 1;
for (int i = 1; i < size; i++) {
if (i == position) {
Node temp = ptr.getLink();
temp = temp.getLink();
ptr.setLink(temp);
break;
}
ptr = ptr.getLink();
}
size--;
}
public void deleteNodeByGivenData(int data) {
if (start == null) {
System.out.println("Empty!");
return;
}
if (start.getData() == data && start.getLink() == null) {
start = null;
end = null;
size--;
return;
}
if (start.getData() == data && start.getLink() != null) {
start = start.getLink();
size--;
return;
}
if (end.getData() == data) {
Node startPtr = start;
Node endPtr = start;
startPtr = startPtr.getLink();
while (startPtr.getLink() != null) {
endPtr = startPtr;
startPtr = startPtr.getLink();
}
end = endPtr;
end.setLink(null);
size--;
return;
}
Node startPtr = start;
Node prevLink = startPtr;
startPtr = startPtr.getLink();
while (startPtr.getData() != data && startPtr.getLink() != null) {
prevLink = startPtr;
startPtr = startPtr.getLink();
}
if (startPtr.getData() == data) {
Node temp = prevLink.getLink();
temp = temp.getLink();
prevLink.setLink(temp);
size--;
return;
}
System.out.println(data + " not found!");
}
public void disply() {
if (start == null) {
System.out.println("Empty!");
return;
}
if (start.getLink() == null) {
System.out.println(start.getData());
return;
}
Node ptr = start;
System.out.print(ptr.getData() + "->");
ptr = start.getLink();
while (ptr.getLink() != null) {
System.out.print(ptr.getData() + "->");
ptr = ptr.getLink();
}
System.out.println(ptr.getData() + "\n");
}
public void searchElementByPosition(int position) {
if (position == 1) {
System.out.println("Element at " + position + " is : " + start.getData());
return;
}
if (position == size) {
System.out.println("Element at " + position + " is : " + end.getData());
return;
}
Node ptr = start;
for (int i = 1; i < size; i++) {
if (i == position) {
System.out.println("Element at " + position + " is : " + ptr.getData());
break;
}
ptr = ptr.getLink();
}
}
public void searchElementIteratively(int data) {
if (isEmpty()) {
System.out.println("Empty!");
return;
}
if (start.getData() == data) {
System.out.println(data + " found at " + 1 + " position");
return;
}
if (start.getLink() != null && end.getData() == data) {
System.out.println(data + " found at " + size + " position");
return;
}
Node startPtr = start;
int position = 0;
while (startPtr.getLink() != null) {
++position;
if (startPtr.getData() == data) {
break;
}
startPtr = startPtr.getLink();
}
if (startPtr.getData() == data) {
System.out.println(data + " found at " + position);
return;
}
System.out.println(data + " No found!");
}
public void searchElementRecursively(Node start, int data, int count) {
if (isEmpty()) {
System.out.println("Empty!");
return;
}
if (start.getData() == data) {
System.out.println(data + " found at " + (++count));
return;
}
if (start.getLink() == null) {
System.out.println(data + " not found!");
return;
}
searchElementRecursively(start.getLink(), data, ++count);
}
public int getSize() {
return size;
}
public boolean isEmpty() {
return start == null;
}
}
public class SinglyLinkedList {
@SuppressWarnings("resource")
public static void main(String[] args) {
SinglyLinkedListImpl listImpl = new SinglyLinkedListImpl();
System.out.println("Singly Linked list : ");
boolean yes = true;
do {
System.out.println("1 Insert At Start :");
System.out.println("2 Insert At End :");
System.out.println("3 Insert At any Position :");
System.out.println("4 Delete At any Position :");
System.out.println("5 Display :");
System.out.println("6 Get Size");
System.out.println("7 Empty Status");
System.out.println("8 Replace data at given postion");
System.out.println("9 Search Element by position ");
System.out.println("10 Delete a Node by Given Data");
System.out.println("11 Search Element Iteratively");
System.out.println("12 Search Element Recursively");
System.out.println("13 Exit :");
Scanner scanner = new Scanner(System.in);
int choice = scanner.nextInt();
switch (choice) {
case 1:
listImpl.insertAtStart(scanner.nextInt());
break;
case 2:
listImpl.insertAtEnd(scanner.nextInt());
break;
case 3:
int position = scanner.nextInt();
if (position <= 1 || position > listImpl.getSize()) {
System.out.println("invalid position!");
} else {
listImpl.insertAtPosition(position, scanner.nextInt());
}
break;
case 4:
int deletePosition = scanner.nextInt();
if (deletePosition <= 1 || deletePosition > listImpl.getSize()) {
System.out.println("invalid position!");
} else {
listImpl.deleteAtPosition(deletePosition);
}
break;
case 5:
listImpl.disply();
break;
case 6:
System.out.println(listImpl.getSize());
break;
case 7:
System.out.println(listImpl.isEmpty());
break;
case 8:
int replacePosition = scanner.nextInt();
if (replacePosition < 1 || replacePosition > listImpl.getSize()) {
System.out.println("Invalid position!");
} else {
listImpl.repleaceDataAtPosition(replacePosition, scanner.nextInt());
}
break;
case 9:
int searchPosition = scanner.nextInt();
if (searchPosition < 1 || searchPosition > listImpl.getSize()) {
System.out.println("Invalid position!");
} else {
listImpl.searchElementByPosition(searchPosition);
}
break;
case 10:
listImpl.deleteNodeByGivenData(scanner.nextInt());
break;
case 11:
listImpl.searchElementIteratively(scanner.nextInt());
break;
case 12:
listImpl.searchElementRecursively(listImpl.start, scanner.nextInt(), 0);
break;
default:
System.out.println("invalid choice");
break;
}
} while (yes);
}
}
Cela vous aidera dans la liste chaînée.
Liste chaînée pour illustrer les opérations Insérer avant, Supprimer avant, Insérer arrière et Supprimer arrière en Java:
import Java.io.DataInputStream;
import Java.io.IOException;
public class LinkedListTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
Node root = null;
DataInputStream reader = new DataInputStream(System.in);
int op = 0;
while(op != 6){
try {
System.out.println("Enter Option:\n1:Insert Front 2:Delete Front 3:Insert Rear 4:Delete Rear 5:Display List 6:Exit");
//op = reader.nextInt();
op = Integer.parseInt(reader.readLine());
switch (op) {
case 1:
System.out.println("Enter Value: ");
int val = Integer.parseInt(reader.readLine());
root = insertNodeFront(val,root);
display(root);
break;
case 2:
root=removeNodeFront(root);
display(root);
break;
case 3:
System.out.println("Enter Value: ");
val = Integer.parseInt(reader.readLine());
root = insertNodeRear(val,root);
display(root);
break;
case 4:
root=removeNodeRear(root);
display(root);
break;
case 5:
display(root);
break;
default:
System.out.println("Invalid Option");
break;
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("Exited!!!");
try {
reader.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
static Node insertNodeFront(int value, Node root){
Node temp = new Node(value);
if(root==null){
return temp; // as root or first
}
else
{
temp.next = root;
return temp;
}
}
static Node removeNodeFront(Node root){
if(root==null){
System.out.println("List is Empty");
return null;
}
if(root.next==null){
return null; // remove root itself
}
else
{
root=root.next;// make next node as root
return root;
}
}
static Node insertNodeRear(int value, Node root){
Node temp = new Node(value);
Node cur = root;
if(root==null){
return temp; // as root or first
}
else
{
while(cur.next!=null)
{
cur = cur.next;
}
cur.next = temp;
return root;
}
}
static Node removeNodeRear(Node root){
if(root==null){
System.out.println("List is Empty");
return null;
}
Node cur = root;
Node prev = null;
if(root.next==null){
return null; // remove root itself
}
else
{
while(cur.next!=null)
{
prev = cur;
cur = cur.next;
}
prev.next=null;// remove last node
return root;
}
}
static void display(Node root){
System.out.println("Current List:");
if(root==null){
System.out.println("List is Empty");
return;
}
while (root!=null){
System.out.print(root.val+"->");
root=root.next;
}
System.out.println();
}
static class Node{
int val;
Node next;
public Node(int value) {
// TODO Auto-generated constructor stub
val = value;
next = null;
}
}
}
Comment ai-je créé une liste chaînée comme celle-ci? Comment cela fonctionne-t-il? C'est toute une liste chaînée. Un élément avec un lien vers le prochain élément de la liste. Tant que vous conservez une référence à l'élément au début de la liste, vous pouvez parcourir l'intégralité en utilisant chaque référence ultérieure à la valeur suivante.
Pour ajouter, tout ce que vous avez à faire est de trouver la fin de la liste et de donner à l'élément suivant la valeur que vous souhaitez ajouter. Par conséquent, si l'option a la valeur non-null next, vous devrez appeler append sur l'élément suivant jusqu'à ce que vous trouviez l'élément. fin de la liste.
this.next.Append(Word);
Veuillez lire cet article: Comment implémenter une classe LinkedList à partir de zéro en Java
package com.crunchify.tutorials;
/**
* @author Crunchify.com
*/
public class CrunchifyLinkedListTest {
public static void main(String[] args) {
CrunchifyLinkedList lList = new CrunchifyLinkedList();
// add elements to LinkedList
lList.add("1");
lList.add("2");
lList.add("3");
lList.add("4");
lList.add("5");
/*
* Please note that primitive values can not be added into LinkedList
* directly. They must be converted to their corresponding wrapper
* class.
*/
System.out.println("lList - print linkedlist: " + lList);
System.out.println("lList.size() - print linkedlist size: " + lList.size());
System.out.println("lList.get(3) - get 3rd element: " + lList.get(3));
System.out.println("lList.remove(2) - remove 2nd element: " + lList.remove(2));
System.out.println("lList.get(3) - get 3rd element: " + lList.get(3));
System.out.println("lList.size() - print linkedlist size: " + lList.size());
System.out.println("lList - print linkedlist: " + lList);
}
}
class CrunchifyLinkedList {
// reference to the head node.
private Node head;
private int listCount;
// LinkedList constructor
public CrunchifyLinkedList() {
// this is an empty list, so the reference to the head node
// is set to a new node with no data
head = new Node(null);
listCount = 0;
}
public void add(Object data)
// appends the specified element to the end of this list.
{
Node crunchifyTemp = new Node(data);
Node crunchifyCurrent = head;
// starting at the head node, crawl to the end of the list
while (crunchifyCurrent.getNext() != null) {
crunchifyCurrent = crunchifyCurrent.getNext();
}
// the last node's "next" reference set to our new node
crunchifyCurrent.setNext(crunchifyTemp);
listCount++;// increment the number of elements variable
}
public void add(Object data, int index)
// inserts the specified element at the specified position in this list
{
Node crunchifyTemp = new Node(data);
Node crunchifyCurrent = head;
// crawl to the requested index or the last element in the list,
// whichever comes first
for (int i = 1; i < index && crunchifyCurrent.getNext() != null; i++) {
crunchifyCurrent = crunchifyCurrent.getNext();
}
// set the new node's next-node reference to this node's next-node
// reference
crunchifyTemp.setNext(crunchifyCurrent.getNext());
// now set this node's next-node reference to the new node
crunchifyCurrent.setNext(crunchifyTemp);
listCount++;// increment the number of elements variable
}
public Object get(int index)
// returns the element at the specified position in this list.
{
// index must be 1 or higher
if (index <= 0)
return null;
Node crunchifyCurrent = head.getNext();
for (int i = 1; i < index; i++) {
if (crunchifyCurrent.getNext() == null)
return null;
crunchifyCurrent = crunchifyCurrent.getNext();
}
return crunchifyCurrent.getData();
}
public boolean remove(int index)
// removes the element at the specified position in this list.
{
// if the index is out of range, exit
if (index < 1 || index > size())
return false;
Node crunchifyCurrent = head;
for (int i = 1; i < index; i++) {
if (crunchifyCurrent.getNext() == null)
return false;
crunchifyCurrent = crunchifyCurrent.getNext();
}
crunchifyCurrent.setNext(crunchifyCurrent.getNext().getNext());
listCount--; // decrement the number of elements variable
return true;
}
public int size()
// returns the number of elements in this list.
{
return listCount;
}
public String toString() {
Node crunchifyCurrent = head.getNext();
String output = "";
while (crunchifyCurrent != null) {
output += "[" + crunchifyCurrent.getData().toString() + "]";
crunchifyCurrent = crunchifyCurrent.getNext();
}
return output;
}
private class Node {
// reference to the next node in the chain,
// or null if there isn't one.
Node next;
// data carried by this node.
// could be of any type you need.
Object data;
// Node constructor
public Node(Object dataValue) {
next = null;
data = dataValue;
}
// another Node constructor if we want to
// specify the node to point to.
public Node(Object dataValue, Node nextValue) {
next = nextValue;
data = dataValue;
}
// these methods should be self-explanatory
public Object getData() {
return data;
}
public void setData(Object dataValue) {
data = dataValue;
}
public Node getNext() {
return next;
}
public void setNext(Node nextValue) {
next = nextValue;
}
}
}
Sortie
lList - print linkedlist: [1][2][3][4][5]
lList.size() - print linkedlist size: 5
lList.get(3) - get 3rd element: 3
lList.remove(2) - remove 2nd element: true
lList.get(3) - get 3rd element: 4
lList.size() - print linkedlist size: 4
lList - print linkedlist: [1][3][4][5]
class Node { int data; Node next; public Node(int data) { this.data = data; this.next = null; } } public class LinkedListManual { Node node; public void pushElement(int next_node) { Node nd = new Node(next_node); nd.next = node; node = nd; } public int getSize() { Node temp = node; int count = 0; while (temp != null) { count++; temp = temp.next; } return count; } public void getElement() { Node temp = node; while (temp != null) { System.out.println(temp.data); temp = temp.next; } } public static void main(String[] args) { LinkedListManual obj = new LinkedListManual(); obj.pushElement(1); obj.pushElement(2); obj.pushElement(3); obj.getElement(); //get element System.out.println(obj.getSize()); //get size of link list } }