C++ linked lists read access violation - c++

Question

I'm new to C++ and I'm currently studying linked lists and I came upon this problem and I still can't find a solution.
This is how a basic node looks like.
struct node {
int data;
node *next;
};
I'm trying to swap the position of the first and the last node with this function.
void swap_first_and_last() {
node *temp = new node;
node *temp2 = new node;
temp->data = head->data;
temp->next = NULL;
temp2->next = head->next;
temp2->data = tail->data;
head = temp2;
tail = temp;
}
The error I'm getting is: Exception thrown: read access violation, this->tail was nullptr.
Can anyone explain what I'm doing wrong?

Answer 1

You havn't deleted head & tail.
Assuming tail is the last, there is somewhere a node::next pointing to it, and you didn't changed it to point to temp
What if the list is empty? you didn't checked if head or tail is null.
Edit added fixed method
void swap_first_and_last()
{
//if there is less than 2 nodes - finished.
if(!head || !tail || head==tail) return;
node *temp = new node;
node *temp2 = new node;
node *temp3;
temp->data = head->data;
temp->next = NULL;
temp2->next = head->next;
temp2->data = tail->data;
temp3 = head;
head = temp2;
delete temp3; //delete old head
temp3 = tail;
//find the tail previous
for(tail=head; tail->next!=temp3;tail=tail->next);
//make tail previous point to tail
tail->next = temp;
tail = temp;//now it will point to new tail...
delete temp3;//delete old tail
}
A better solution:
void swap_first_and_last()
{
node *temp;
//if there is less than 2 nodes - finished.
if(!head || !tail || head==tail) return;
for(temp=head; temp->next!=tail;temp=temp->next);
temp->next = head; //set tail precedor's next to point to head, prepere for head = tail
tail->next = head->next; //set tail's next to point head->next, prepere for head = tail
head = tail; //set tail as head
tail = temp->next; //set old head as tail
tail->next = NULL; // tail next is always null (was point to the 2nd).
}

Answer 2

// V----- where does tail get initialized?
temp2->data = tail->data;
When swap_first_and_last is called, but tail hasn't been initialized, just as the runtime says: you're going to have a bad time.
You can either -
Make sure that tail is initialized with a value before calling
swap_first_and_last
Check to see if tail is initialized before
trying to do any read access on it.
I think the latter is a better option.
if (head) {
temp->data = head->data;
}
if (tail) {
temp2->data = tail->data;
}
A question you should ask yourself - why don't I put this initialization in the constructor of node?

Answer 3

Your new to C++ so I understand this isn't particularly easy to grasp, but once you get the hang of it you will understand the comments above.
head and tail are pointers node *head; so you don't need to create copies of the objects that they point to.
head points to a block of memory that has the content (data = 42; next = tail) and tail points to a block of memory that holds (7 and null). You can copy head into temp and tail into temp2 and then copy them back into tail and head but why? What do you gain by creating copies of the memory blocks, apart from memory leaks? You don't care about the blocks of memory, you don't want to move them, you don't want to change them all you want to do is change which pointer points to which block of memory.
node* pTemp = head;
head = tail;
tail = head;
Unfortunately this breaks your list because now head->next = null so you just need to repair that:
pTemp = head->next; // Which should always be null.
head->next = tail->next;
tail->next = pTemp;
Now if you stick that in a little function that takes the two pointers as parameters you have a block of code that can switch any two given nodes in your list, meaning sorting your list becomes a lot easier.