How to convert linked list to circular linked list? - c++

Question

This is my linked list constructor and insertion function:
template <class T>
List<T>::List() {
_first = nullptr;
}
template <class T>
bool List<T>::insert(const T& item, const int& position) {
Node* ptr = new Node();
// sets node data members
ptr->data = item;
ptr->next = nullptr;
if (position == 1) {
ptr->next = _first;
_first = ptr;
return true;
}
// iterates through list until reached position passed into function
Node* predptr = _first;
for (int i = 0; i < position - 2; i++) {
predptr = predptr->next;
}
// repoints pointer of previous node to it and its pointer to what previous pointer was pointing too
ptr->next = predptr->next;
predptr->next = ptr;
return true;
}
I tried this before but screwed my whole program up and got lost so I just reverted back to what I had working as a starting point.
In my notes it says to traverse the list do this:
(_first != 0) {
ptr = first;
do
{ // process ptr->data
ptr = ptr->next; }
while (ptr != _first);
}
but when I tried changing the code to add this, it just screwed everything up. If I could get pointed in the right direction, i'd appreciate it, thanks!

Answer 1

I do not have your code so it is not tested. But I think this would work. First to make clear, I use zero-based-indices.
For the first part:
Tipp You can pass position as copy because a reference to int has the same size as the int itself. For larger object though it would make sense.
I added a member size function which counts the number of elements. The two asserts are assuring that you do not pass a position which is greater than the number of elements in the list. The second one guarantees that the special case is correctly as it tests if _first == nullptr then position must be zero because no other element has been added before.
// create the node
Node* ptr = new Node();
// just to make sure position is not out of bounds
assert(position <= size);
size++;
// sets node data members
ptr->data = item;
// special case, list is empty
if (_first == nullptr)
{
// position must be 0 if you insert for the first time
assert(position == 0);
ptr->next = ptr;
_first = ptr;
return true;
}
Ok for the second part:
When you have already inserted one element you can loop over all elements. I used a special node which is pointing to _first and started the looping at position -1 this should ensure you get the previous element to reassign the pointers accordingly.
// create special-node pointing to first node
Node* predptr = new Node();
predptr->next = _first;
for (int i = -1; i < position; ++i)
{
if (i == position - 1)
{
ptr->next = predptr->next;
predptr->next = ptr;
}
predptr->next = predptr;
}
return true;
I hope that works for you.