Attempted insert node leads to infinite linked list [closed] - c++

Question

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 6 years ago.
Improve this question
I am trying to insert a node into a linked list after it finds a name in the list.
My problem is that when i print out the linked list it prints the nodes up to and including the node containing the name but then outputs infinitely the node I inserted. Any help would be greatly appreciated. Thanks!
(some extra information),(the pointer student is pointing to a dynamically created node already). :)
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

You have to simply insert your new node between curr & prev
If you really want to appreciate accept and upvote the answer
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

Your function is too complicated. The more complicated function the more bugs it contains and it is more difficult to read it.:)
The function can be written the following way. I assume that there are defined the following functions
getNext, setNext, getPrev, setPrev
^^^^
Here you are.
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;
}
Take into account that if the list also has a data member called something like tail then the function also has to change the tail variable if current->getNext is equal to nullptr.
For example
if ( current->getNext() != nullptr )
{
current->getNext()->setPrev( student );
}
else
{
tailP = student;
//^^^^
}
Here is a demonstrative program that shows how the class could be defined using your approach
#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;
}
The program output is
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