C++ linked list append and delete after

So I created a code that asks user for two lists, and then appends second list to the first one, it gets appended after the position of user inputted number on the first list, example:

First list:
1
2
3
4
5
Second list:
11
22
33
44
55
Position after which to be appended: 2
1
2
11
22
33
44
55
3
4
5

The problem I'm getting is that when I delete these lists, it tries to delete the same element twice, giving this execution ?code? - (0xC0000374).
I added debugging test with cout, and realized that the element that is getting deleted twice is the first element of the second list.

My code:

struct elem
{
int num;
elem *next;
};
void add_element (elem*&first1, elem*&last1, int i)
{
elem *p = new elem;
p->num = i;
p->next = NULL;
if (first1 == NULL) first1 = p;
else last1->next = p;
last1 = p;
};
void print_list (elem *first1)
{
for (elem *p = first1; p!=NULL; p=p->next)
{
cout << p->num << endl;
};
}
void delete_list (elem*&first1)
{
elem* p = first1;
while (p != NULL) {
first1 = first1->next;
p->next = NULL;
cout << "Deleting element at address " << p << endl;
delete p;
p = first1;
}
}
void insert_list(elem*& first1, elem*& last1, elem* p, elem* first2, elem* last2) {
// Update the next pointer of the last element of the second list to point to NULL
last2->next = NULL;
if (p == NULL) { // Insert at the beginning of the list
if (first1 == NULL) {
first1 = first2;
} else {
last2->next = first1;
first1 = first2;
}
if (last1 == NULL) {
last1 = last2;
} else {
last1 = last2;
// Update the last1 pointer to point to the last element in the second list
while (last1->next != NULL) {
last1 = last1->next;
}
}
} else if (p == last1) { // Insert at the end of the list
last1->next = first2;
last1 = last2;
} else { // Insert in the middle of the list
last2->next = p->next;
p->next = first2;
}
}
int main()
{
elem *first1=NULL, *last1=NULL, *p;
int i;
cout << "Enter the values of elements (end input with '0'): " << endl;
cin >> i;
while (i != 0)
{
add_element (first1, last1, i);
cin >> i;
};
cout << "\nThe list: " << endl;
print_list (first1);
elem* first2 = NULL;
elem* last2 = NULL;
cout << "\nEnter the values of elements for the second list (end input with '0'): " << endl;
cin >> i;
while (i != 0) {
add_element(first2, last2, i);
cin >> i;
}
cout << "\nEnter the position of the element after which to insert the second list: ";
int pos;
cin >> pos;
// Find the element at the specified position
p = first1;
for (int i = 1; i < pos && p != NULL; i++) {
p = p->next;
}
// Check if the specified position is valid
if (p == NULL) {
cout << "\nError: Position out of range." << endl;
return 0;
}
// Insert the second list after the specified element
insert_list(first1, last1, p, first2, last2);
cout << "\nThe updated list: " << endl;
print_list(first1);
cout << endl;
delete_list(first1);
delete_list(first2);
cout << endl;
if(first2->next) cout << "first2 pastaav " << endl;
return 0;
}

I've tried ChatGPT, but that didn't work really, maybe I don't know how to use it properly :D.
I'll add picture with example: https://prnt.sc/gBCe0WCfHF5q

As the comments already pointed out, you are inserting the nodes, not the elements, into your first list. This causes the second list to point into the first list.

It looks like this:

main::p1 ->  1 -  2 -  3 -  4 -  5  
main::p2 -> 11 - 22 - 33 - 44 - 55

after your insertion, it looks like this:

main::p1 ->  1 -  2 \                          / 3 -  4 -  5  
main::p2 -> ---------\ 11 - 22 - 33 - 44 - 55 /

When you now try to delete both lists, you will get a double deletion, because main still has a reference to 11 via p2, even p1 now "owns" it.

A quick fix would be, when you override the first pointer of the second list with the next pointer of the last element of the second list. This may have the disadvantage, that it does nothing, when the pointer was copied before.

Imagine the following, and you insert the first 5 elements into p1:

main::p1 ->  1 -  2 -  3 -  4 -  5  
main::p2 -> 11 - 22 - 33 - 44 - 55 - 66

Then it would look like this:

main::p1 ->  1 -  2 - 11 - 22 - 33 - 44 - 55 -  3 -  4 -  5  
main::p2 -> 66

And you can safely delete both lists.

void insert_list(elem*& first1, elem* p, elem*& first2, elem* last2) {
// Store the next pointer of last2 for later deletion.
auto last2next = last2->next;
// Update the next pointer of the last element of the second list to point to NULL
// last2->next = NULL; // Redundant, must be allways overridden with p->next or first anyway.
// Assuming you insert after p
// Insert at the beginning of the list, when p == nullptr
auto*& begin_pointer = (p == nullptr) ? first1 : p->next;
last2->next = begin_pointer;
begin_pointer = first2;
// override the original first2 pointer with the saved last2.next pointer.
first2 = last2next;
}

===

But to give you general feedback: Your code looks more like C than C++.
First, you should use nullptr instead of NULL.
(Same applies for FALSE -> false and TRUE true). Those makros are all pure C.

Second, unless this is a school or university task, you should avoid raw pointers (T*). Instead, use smart pointers like std::unique_ptr<T> or std::shared_ptr<T>.

In c++ mostly everything is handled via indirect dynamic memory management. This means, that you pass control structures either by value or by const&. They keep track of their own internal dynamic memory. As soon they go out of scope, they clear their own allocated resources. This principle is called RAII.

Using unique_ptr might be a bit complicated, because you can't copy them, but you can std::move them, which basically steals the ownership: auto new_ptr_owner = std::move(varname_of_old_unique_ptr);

This forces you, to do memory management correct. And is also as efficient as the use of raw pointers.
If you don't care for efficiency, you could just use shared_ptr. They are copyable, because they count all copies of it. When the count reaches zero, the pointer deletes the own resources.

Third, you might want to define your linked list, to always contain an invalid first element, which is basically your list. It is empty, when your first list element has no next value. This will reduce code overhead, because you are not required to check if p is nullptr, since it will always be a valid element.

Alternatively, write a wrapper class:

class LinkedList {
struct Node {
int value{};
std::unique_ptr<Node > next;
Node* prev {}; // Not required, convenience
};
std::unique_ptr<Node> first; // Required
Node* last;  // Optional, to quickly insert at the end.
size_t size;    // Optional, convenience.
public:
void insert(Node begin_n, Node last_n); // Todo implement
void emplace_last(int value); // Todo implement
}; 

Note, that each node can only be reached over one smart pointer at the same time. With a unique_ptr it won't compile, with a shared_ptr you will get a dependency loop (They will keep them alive reciprocally).