Fonction de recherche - Liste chaînée

Question

Je travaille sur une fonction de recherche pour rechercher une valeur spécifique dans une liste chaînée. Quand il trouve cette valeur, je veux sortir sa position. Je n'arrive pas à dépasser le premier nœud sans avoir d'erreur. Je pense que quelque chose ne va pas avec les boucles mais je ne sais pas quoi.

int NumberList::search(double num) 
{ 
    ListNode *nodePtr; 
    nodePtr=head; 
    int i=0; 
    while (nodePtr->value!= NULL) 
    { 
     i=i+1; 
     if (nodePtr->value==num) 
      return i; 
     else 
      nodePtr=nodePtr->next; 
    } 
    return 0; 
} 

Answer 1

Votre boucle while est incorect. Vous devriez tester que nodePtr n'est pas NULL

while (nodePtr != NULL) 
{ 
    i = i + 1; 
    if (nodePtr->value == num) 
     return i; 
    else 
     nodePtr = nodePtr->next; 
} 

Aussi c'est une raison parfaite d'utiliser nullptr au lieu de NULL lorsqu'ils traitent avec des pointeurs. Si vous aviez utiliser nullptr puis

while (nodePtr->value!= nullptr) 

Souhaitez-vous donner une erreur de compilation que vous ne pouvez pas comparer un double-nullptr

Answer 2

Votre tout état de boucle doit être:

while (nodePtr != NULL) 

En raison de cette erreur vous sont susceptibles de visiter un nœud dont le pointeur est NULL Et en déréférenciant cela, vous causez undefined comportement.

Answer 3

Vous ne montrez pas le type ListNode mais je suppose que le value est un double.

while (nodePtr->value != NULL)

Vous êtes ici vérifier si le double n'est pas NULL (NULL est essentiellement 0). Mais vous devez tester nodePtr contre NULL.

Note: Pensez à utiliser nullptr au lieu de NULL, nullptr est le type valeur sûre pour un pointeur nul et aurait produit une erreur de compilation.

error: invalid operands of types 'double' and 'std::nullptr_t' to binary 'operator=='

Answer 4

Je ne sais pas comment la classe correspondante est définie mais je pense que dans tous les cas, la fonction doit regarder la façon suivante

int NumberList::search(double num) 
{ 
    ListNode *nodePtr = head; 
    int i = 0; 

    while (nodePtr != NULL && nodePtr->value != num) 
    { 
     ++i; 
     nodePtr = nodePtr->next 
    } 

    return nodePtr != NULL ? ++i : 0; 
} 

Il est difficile de comparer exactement deux nombres à virgule flottante. Vous devriez utiliser une méthode de comparaison qui prend par exemple en compte un epsilon.

Veuillez également prendre en compte que d'autres fonctions comme par exemple la fonction qui ajoute à la liste des noeuds peuvent aussi se tromper. :)