Read Access Violation when looping through LinkedList - c++

Question

I am creating a planet simulation which makes use of a doubly linked list and several loops to calculate forces, collisions and so on. The issue I am having is a read access violation error when trying to delete a planet due to a collision.
When checking for a collision the smaller of the two planets is deleted, and the way I wrote it is that the smaller planet in the equation can be from the encompassing loop, which if deleted breaks the loop.
A combination of being new to C; staring at the same issue for days now; and that my lecturer for the class is making us use a C/C++ hybrid, is resulting in me struggling to think of an efficient way to fix the issue. Moving the loops out can and has solved the issue, but has a drastic effect on performance of the simulation.
The code can be seen below:
struct planet *head; //Head of list
struct planet *tail; //Tail of list
struct planet {
//Data
float mass;
struct planet *next;
struct planet *prev;
};
planet *remove(struct planet* p) {//Breaking the tree
if (p == head) {
removeHead(); //Method not included in sample due to size and it is sound.
}
else if (p == tail) {
removeTail();//Method not included in sample due to size and it is sound.
}
else {
p->prev->next = p->next;
p->next->prev = p->prev;
}
return p;
}
planet *destroy(struct planet* p) {
if (p) {
if (p != head || p != tail || (!p->next && p->prev)) {
delete p;
printf("Deleted\n");
return 0;
}
else {
printf("Not deleted\n");
return 0;
}
}
}
for (struct planet *p1 = head; p1 != 0; p1 = p1->next)
{
for (struct planet *p3 = head; p3 != 0; p3 = p3->next)
{
//Collision logic
if(p1 != p3){
if(p1->mass >= p3->mass){
destroy(remove(p3)); //Does not cause an error
break;
}else{
destroy(remove(p1)); //Causes the error.
break;
//Deleting p1 here means the for loop can't move on
}
}
}
}
What I am looking for is some advice on how to delete p1 efficiently and without breaking the loop.
Any help is greatly appreciated, and please forgive my less than clean code.

Answer 1

Breaking out of the inner loop when p1 is destroyed, will not break the outer loop, where p1 is dereferenced by the loop control, after it was deleted.
You can avoid it with code perhaps like this. I don't like using for loops with a linked list, and the while makes it easy to set up the next link.
struct planet *p1link, *p3link;
p1 = head;
while(p1 != NULL) {
p1link = p1->next; // collect next link now
p3 = p1->next; // avoid detecting B-A as well as A-B
while(p3 != NULL) {
p3link = p3->next; // collect next link now
//Collision logic
if(p1->mass >= p3->mass){
destroy(remove(p3));
} else {
destroy(remove(p1));
}
p3 = p3link; // next
}
p1 = p1link; // next
}
However the whole concept is flawed, because the p3 you delete might be the next p1 planet. So I suggest including a struct member pending and you make another parse of the list afterwards, to remove dead planets.