尝试插入节点导致无限链接列表

Question

我试图在列表中找到名称后将节点插入到链接列表中。 我的问题是，当我打印出链接列表时，它打印节点直到包含名称的节点，然后无限地输出我插入的节点。任何帮助将不胜感激。谢谢！

（一些额外的信息），（指针学生指向一个动态创建的节点已经）。 :)

bool StudentLinkedList::insertStudentAfter(StudentNode* student, string _name) 
{ 
StudentNode* curr = headP; 
StudentNode* prev = headP; 
while (curr != NULL) 
{ 
    if (curr->getName() == _name) 
    { 


     StudentNode* dummy = curr -> getnext(); 

     curr->setNext(student); 
     prev = prev->getnext(); 

     curr=curr ->getnext(); 
     curr->setNext(dummy); 

     prev = curr; 
     curr = curr->getnext(); 


     length++; 
     return true; 
    } 
    prev = curr; 
    curr = curr->getnext(); 
} 
return false; 

}

Answer 1

你必须只需在curr之间插入新节点& prev

如果你真的想欣赏接受并给予好评的答案

bool StudentLinkedList::insertStudentAfter(StudentNode* student, string _name) 
{ 
StudentNode* curr = headP; 
StudentNode* prev = headP; 
while (curr != NULL) 
{ 
if (curr->getName() == _name) 
{ 
student->setNext(curr->getnext()); 
curr->setNext(student); 
length++; 
return true; 
} 
prev = curr; 
curr = curr->getnext(); 
} 
return false; 
} 

Answer 2

你的功能实在是太复杂了。功能越复杂，它包含的错误就越多，读起来就越困难。:)

函数可以写成下面的方式。我假设已经定义了以下功能

getNext, setNext, getPrev, setPrev 
    ^^^^ 

给你。

bool StudentLinkedList::insertStudentAfter(StudentNode *student, 
              const std::string &name) 
{ 
    StudentNode *current = headP; 

    while (current != nullptr && current->getName() != name) 
    { 
     current = current->getNext(); 
    } 

    bool success = current != nullptr; 

    if (success) 
    { 
     student->setPrev(current); 
     student->setNext(current->getNext()); 

     if (current->getNext() != nullptr) 
     { 
      current->getNext()->setPrev(student); 
     } 

     current->setNext(student); 
    } 

    return success; 
} 

考虑到，如果该列表还具有称为像尾的数据成员，则函数还具有改变尾变量如果current->getNext等于nullptr。

例如

 if (current->getNext() != nullptr) 
     { 
      current->getNext()->setPrev(student); 
     } 
     else 
     { 
      tailP = student; 
      //^^^^ 
     } 

这里是一个示范项目，显示了如何在类可以用你的方法来定义

#include <iostream> 
#include <string> 

class StudentLinkedList 
{ 
private:  
    class StudentNode 
    { 
    private: 
     StudentNode *next; 
     StudentNode *prev; 
     std::string name; 

    public: 
     StudentNode(const std::string &name) 
      : next(nullptr), prev(nullptr), name(name) {} 

     StudentNode * getNext() const { return next; } 
     StudentNode * getPrev() const { return prev; } 
     const std::string & getName() const { return name; } 

     void setNext(StudentNode *student) { next = student; } 
     void setPrev(StudentNode *student) { prev = student; } 
    } *head = nullptr, *tail = nullptr; 

public: 
    StudentLinkedList() = default; 
    StudentLinkedList(const StudentLinkedList &) = delete; 
    StudentLinkedList & operator =(const StudentLinkedList &) = delete; 
    ~StudentLinkedList() 
    { 
     while (head != nullptr) 
     { 
      StudentNode *tmp = head; 
      head = head->getNext(); 
      delete tmp; 
     } 

     tail = head; 
    } 

    void appendStudent(const std::string &name) 
    { 
     StudentNode *student = new StudentNode(name); 
     appendStudent(student); 
    } 

    void insertStudentAfter(const std::string &current_name, 
          const std::string &new_name) 
    { 
     StudentNode *student = new StudentNode(new_name); 
     insertStudentAfter(student, current_name); 
    } 

    friend std::ostream & operator <<(std::ostream &os, const StudentLinkedList &lsdt); 

private: 
    void appendStudent(StudentNode *student) 
    { 
     if (tail == nullptr) 
     { 
      head = tail = student; 
     } 
     else 
     { 
      tail->setNext(student); 
      tail = tail->getNext(); 
     } 
    } 

    bool insertStudentAfter(StudentNode *student, const std::string &name) 
    { 
     StudentNode *current = head; 

     while (current != nullptr && current->getName() != name) 
     { 
      current = current->getNext(); 
     } 

     bool success = current != nullptr; 

     if (success) 
     { 
      student->setPrev(current); 
      student->setNext(current->getNext()); 

      if (current->getNext() != nullptr) 
      { 
       current->getNext()->setPrev(student); 
      } 
      else 
      { 
       tail = student; 
      } 

      current->setNext(student); 
     } 

     return success; 
    } 
}; 

std::ostream & operator <<(std::ostream &os, const StudentLinkedList &lst) 
{ 
    for (StudentLinkedList::StudentNode *current = lst.head; 
     current != nullptr; 
     current = current->getNext()) 
    { 
     os << current->getName() << ' '; 
    } 

    return os; 
} 

int main() 
{ 
    const size_t N = ('Z' - 'A' + 1)/2; 

    StudentLinkedList students; 

    for (size_t i = 0; i < N; i++) 
    { 
     char name[2] = { char('A' + 2 * i) }; 

     students.appendStudent(name); 
    }  

    std::cout << students << std::endl; 

    for (size_t i = 0; i < N; i++) 
    { 
     char new_name[2] = { char('A' + 2 * i + 1) }; 
     char current_name[2] = { char('A' + 2 * i) }; 

     students.insertStudentAfter(current_name, new_name); 
    }  

    std::cout << students << std::endl; 

    return 0; 
} 

程序输出是

A C E G I K M O Q S U W Y 
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z