Ajout d'articles à la fin de la liste liée

boucle au dernier élément de la liste liée qui présente le prochain pointeur à NULL, puis modifiez le pointer suivant pour pointer sur un nouveau nœud qui possède les données = objet et le pointer suivant = null

Vous souhaitez naviguer dans la liste liée entière à l'aide d'une boucle et vérifiez la valeur "Suivant" pour chaque nœud. Le dernier nœud sera celui dont la prochaine valeur est null. Faites simplement une nouvelle valeur de ce nœud un nouveau nœud que vous créez avec les données d'entrée.

node temp = first; // starts with the first node.

    while (temp.next != null)
    {
       temp = temp.next;
    }

temp.next = new Node(header, x);

Voici un indice, vous avez un graphique de nœuds dans la liste liée et vous gardez toujours une référence à la tête qui est le premier nœud de la liste LinkedList.
Next pointe sur le nœud suivant de la liste Linked Linked Linked LinkedList. Lorsque vous êtes ensuite NULL, vous êtes à la fin de la liste.

class Node {
    Object data;
    Node next;
    Node(Object d,Node n) {
        data = d ;
        next = n ;
       }

   public static Node addLast(Node header, Object x) {
       // save the reference to the header so we can return it.
       Node ret = header;

       // check base case, header is null.
       if (header == null) {
           return new Node(x, null);
       }

       // loop until we find the end of the list
       while ((header.next != null)) {
           header = header.next;
       }

       // set the new node to the Object x, next will be null.
       header.next = new Node(x, null);
       return ret;
   }
}

Voici une solution partielle à votre classe de liste liée, j'ai laissé le reste de la mise en œuvre à vous et a également laissé la bonne suggestion d'ajouter un nœud queue dans le cadre de la liste liée à vous.

Le fichier de nœud: xxx

et voici un fichier de liste liée: xxx

Les programmes ci-dessus peuvent vous donner NullPointerException. C'est un moyen plus facile d'ajouter un élément à la fin de la liste liée.

public class LinkedList {
    Node head;

    public static class Node{
        int data;
        Node next;

        Node(int item){
            data = item;
            next = null;
        }
    }
    public static void main(String args[]){
        LinkedList ll = new LinkedList();
        ll.head = new Node(1);
        Node second = new Node(2);
        Node third = new Node(3);
        Node fourth = new Node(4);

        ll.head.next = second;
        second.next = third;
        third.next = fourth;
        fourth.next = null;

        ll.printList();
        System.out.println("Add element 100 to the last");
        ll.addLast(100);
        ll.printList();
    }
    public void printList(){
        Node t = head;
        while(n != null){
            System.out.println(t.data);
            t = t.next;
        }

    }

    public void addLast(int item){
        Node new_item = new Node(item);
        if(head == null){
            head = new_item;
            return;
        }
        new_item.next = null;

        Node last = head;
        Node temp = null;
        while(last != null){
            if(last != null)
                temp = last;
            last = last.next;
        }   

        temp.next = new_item;   
        return;
    }
}

L'addlast () nécessite une certaine optimisation car la boucle tandis que la boucle d'addlast () a o (n) complexité. Vous trouverez ci-dessous ma mise en œuvre de LinkedList. Exécutez le code avec ll.addlastx (i) une fois et exécutez-le avec ll.adddlast (i) à nouveau, vous pouvez voir que leur est beaucoup de différence dans le temps de traitement de AddLastex () avec AddLast ().

nœud.java xxx

linkedlist.java xxx

Si vous gardez une trace du nœud queue, vous n'avez pas besoin de boucler à chaque élément de la liste.

Il suffit de mettre à jour la queue pour pointer vers le nouveau nœud: P>

AddValueToListEnd(value) {
    var node = new Node(value);

    if(!this.head) {
        this.head = node;
        this.tail = node;
    } else {
        this.tail.next = node; //point old tail to new node
    }
        
    this.tail = node; //now set the new node as the new tail
}

• créer un nouveau nœud avec la valeur donnée li>
• Si la liste est vide, la tête du point et la queue du nouveau nœud li>
• Si la liste n'est pas vide, définissez l'ancienne queue.Next pour être le nouveau nœud li>
• Dans les deux cas, mettez à jour le pointeur de la queue pour être le nouveau nœud li> ul> p>

public static Node insertNodeAtTail(Node head,Object data) {
               Node node = new Node(data);
                 node.next = null;
                if (head == null){
                    return node;
                }
                else{
                    Node temp = head;
                    while(temp.next != null){
                        temp = temp.next;
                    }
                    temp.next = node; 
                    return head;
                }        
    }