2 Linked list merge difficulties - c++

Question

I am trying to merge two linked lists. One issue I have is how I can have my while loop continue to run even after 1 list reaches the end.
E.G: List1 values: 1, 3;
List 2 values: 2,6,7,8;
Ideally the output would be: 1,2,3,6,7,8
Currently my output is more like 1,2,3 (list1 has reached the end so the loop stops and the other list 2 values don't get added to the list).
Also, I would like for my merge to not be destructive to the original 2 lists that I merge, how can I accomplish this?
struct Node
{
int value;
Node *next;
};
void addNode(Node* &head, int x)
{
Node* temp = new Node;
temp->value = x;
temp->next = nullptr;
if(!head)
{
head = temp;
return;
}
else
{
Node* last = head;
while(last->next)
last=last->next;
last->next = temp;
}
}
void merge(Node * &head1, Node * &head2, Node * &head3)
{
while (head1 != nullptr && head2 != nullptr)
{
if (head1->value < head2->value)
{
addNode(head3, head1->value);
head1 = head1->next;
}
else
{
addNode(head3, head2->value);
head2 = head2->next;
}
}
}
Main function:
int main()
{
Node *head = nullptr;
Node *head2 = nullptr;
Node *head3 = nullptr;
for (int i=0; i<=8; i+=2)
addNode(head, i);
for (int i=1; i<=5; i++)
addNode(head2, i);
merge(head, head2, head3);
printList(head);
printList(head2);
printList(head3);
system("PAUSE");
return 0;
}

Answer 1

Nikos M. answered your first question, his answer is fine, so I won't repeat it. This answer addresses your second question:
Also, I would like for my merge to not be destructive to the original 2 lists that I merge, how can I accomplish this?
The answer is simple: Don't pass head1 and head2 by reference:
void merge(Node * head1, Node * head2, Node * &head3)
In fact, I would recommend making head1 and head2 const pointers:
void merge(const Node * head1, const Node * head2, Node * &head3)

Answer 2

The while loop exits as soon as either head1 or head2 becomes null. I think you want to add an extra piece of code to just append all remaining elements from the non-empty list (Im assuming they're already sorted).
Node* lastElements = list1 != nullptr ? list1 : list2;
while( lastElements != nullptr )
{
addNode(list3, lastElements->value);
lastElements = lastElements->next;
}
Add a constructor to Node so that next is always initialised to nullptr. I originally read code wrong an thought you'd missed this initialisation but adding a constructor will simplify your code and mean you wont forget to initialise next pointer if you create nodes elsewhere.
Node( int initValue)
: value(initValue)
, next(nullptr)
{}
and the start of your addNode function becomes 1 line instead of 3.
Node* temp = new Node(x);
Dont pass in reference to head1 and head2 pointers if the merge is not to be destructive. So something like this.
void merge( const Node* head1, const Node* head2, Node3*& outHead3)
{
//copy pointers in order to iterate through list
Node* current1 = head1;
Node* current2 = head2;
while( current1 != nullptr && current2 != nullptr)
{
//as before with relevant name changes
.
.
.
}
Node* lastElements = current1 != nullptr ? current1 : current2;
while( lastElements != nullptr )
{
addNode(outHead3, lastElements->value);
lastElements = lastElements->next;
}
}

Answer 3

you forget to merge any remaining items, use this:
// dont pass head1, head2 by reference in method call
void merge(Node * head1, Node * head2, Node * &head3)
{
// and/or use other variables to avoid changing head1, head2
Node * list1 = head1;
Node * list2 = head2;
while (list1 != nullptr && list2 != nullptr)
{
if (list1->value < list2->value)
{
addNode(head3, list1->value);
list1 = list1->next;
}
else
{
addNode(head3, list2->value);
list2 = list2->next;
}
}
// merge any remaining list1 items
while (list1 != nullptr)
{
addNode(head3, list1->value);
list1 = list1->next;
}
// merge any remaining list2 items
while (list2 != nullptr)
{
addNode(head3, list2->value);
list2 = list2->next;
}
}