Retirez la première occurrence d'un élément, et toutes les occurrences d'un élément dans une liste, avec récursion

Question

Je suis en train de mettre en œuvre une méthode supprimer et deleteAll pour éliminer une occurrence ou toutes les occurrences d'une chaîne de mon liée liste utilisant recursion, puis retourne un objet LLNode. Dans mon code, je suis, conceptuellement, en train d'essayer d'identifier si un noeud (ie node1) pointe vers un noeud avec une occurrence de l'élément spécifié (node2), et si c'est le cas, node1 pointe vers le noeud qui node2 pointe vers.

Mon code fonctionne pour la plupart, mais le problème que je rencontre est qu'il semble sauter le premier nœud de la liste.

public class LinkedTest { 

public static void main(String[] args) { 
    // TODO Auto-generated method stub 

    LLNode<String>list = new LLNode<>("susan"); 
    list = addNode(list, "matt"); 
    list = addNode(list, "susan"); 
    list = addNode(list, "bob"); 
    list = addNode(list, "matt"); 

    printNodes(list); 

    list = deleteAll(list, "susan"); 
    System.out.println("\nPrint nodes forward after delete of susan"); 
    printNodes(list); 

    list = deleteAll(list, "matt"); 
    System.out.println("\nPrint nodes forward after delete of matt"); 
    printNodes(list); 
} 

public static LLNode<String> addNode(LLNode<String> list, String info) { 
    LLNode<String> newNode = new LLNode<>(info); 
    newNode.setLink(list); 
    list = newNode; 
    return list; 
} 

public static void printNodes(LLNode<String> node) { 
    System.out.println("Print list forward"); 
    while (node != null) { 
     System.out.println(node.getInfo()); 
     node = node.getLink(); 
    } 
} 

public static LLNode<String> delete(LLNode<String> node, String name){ 
    if(node.getLink().getInfo() != name){ 
     delete(node.getLink(), name); 
    } 
    node.setLink(node.getLink().getLink()); 
    return node; 
} 

public static LLNode<String> deleteAll(LLNode<String> node, String name){ 
    if(node.getLink() != null){ 
     deleteAll(node.getLink(), name); 

     if(node.getLink().getInfo() == name){ 
      node.setLink(node.getLink().getLink()); 
     } 
    } 
    return node; 
} 

} 

Lorsque cela est exécuté, c'est le résultat:

Print list forward 
matt 
bob 
susan 
matt 
susan 

Print nodes forward after delete of susan 
Print list forward 
matt 
bob 
matt 

Print nodes forward after delete of matt 
Print list forward 
matt 
bob 

Dans la sortie, vous pouvez voir que la première instance de « mat » n'a pas été supprimé. Le même problème se produit lors de l'implémentation de la méthode delete. Toute aide est grandement appréciée!

Answer 1

En voyant getLink().getLink() une sonnerie d'alarme doit sonner; getLink() pourrait être nul, et surtout le code est trop indirect, la distinction de cas trop complexe.

La comparaison de chaînes s'effectue par .equals.

Suppression de la première occurrence irait:

public static LLNode<String> delete(LLNode<String> node, String name){ 
    if (node == null) { // Simplest case. 
     return null; 
    } 
    if (node.getInfo().equals(name)) { // Actual deletion work. 
     return node.getLink(); // First occurrence deleted only. 
    } 
    node.setLink(delete(node.getLink(), name)); // Recursion. 
    return node; 
} 

l'intention de votre code a été un manque return avant la delete récursive ou plus.