twist a doubly linked list - c++

Question

I have a Chain class that is made of a doubly linked list.
I want to twist two Chains so that every node at even positions will swap with each other. The Chain starts at position 1.
For example, say
this = {1,2,3,4}; //default chain
aChain = {5,6,7,8};
twist(aChain);
Now this would be {1,6,3,8}
and aChain would be {5,2,7,4}
Current Update:
void Chain::twist(Chain & other){
Node* firstOdd1 = this -> head_;
Node* firstOdd2 = other -> head_;
Node* firstEven1 = firstOdd1 -> next;
Node* firstEven2 = firstOdd2 -> next;
for(int i = 0; i < size(); i++){
firstOdd1 -> next = firstEven2;
firstOdd2 -> next = firstEven1;
firstEven1 -> prev = firstOdd2;
firstEven2 -> prev = firstOdd1;
if(firstEven1 -> next != NULL && firstEven2 -> next != NULL){
//updating my pointers for the next iteration
firstOdd1 = firstEven1 -> next;
firstOdd2 = firstEven2 -> next;
firstEven1 = firstOdd1 -> next;
firstEven2 = firstOdd2 -> next;}
else break;
}
}
As you see, I declared 4 pointers so that I don't lose any nodes during my assignments. I also have tail pointers that I need to assign to the last Nodes of both lists after the loop I suppose (if last Nodes are swapped). There's a size() function in the class that return the size of the chain.
This is what I wrote for the iteration step just now.

Answer 1

I left this as a comment, but I might as well make it an answer:
The algorithm is simple: swap the values at every even node in the chain.
No need to start worrying about tails and whatnot, just follow that pattern until you can no longer do it (i.e. you run out of even nodes), then stop and voila, problem solved!
You can clearly see it for the case you submitted:
{1,2,3,4};
{5,6,7,8};
==========
TWISTER
==========
| | |
v v v
{1,6,3,8};
{5,2,7,4};
Another example:
{1,2,3};
{5,6,7,8,9};
==========
TWISTER
==========
| | |
v v v
{1,6,3};
{5,2,7,8,9};
Another one!
{};
{5,6,7,8,9};
==========
TWISTER
==========
| | |
v v v
{};
{5,6,7,8,9};
ONE MORE TIME!
{1};
{5};
==========
TWISTER
==========
| | |
v v v
{1};
{5};
Maybe to help you, create a function which when called with a given node, tells you if it is possible to move it to the next even position.
bool can_move_to_even(Node* node) const {
if (node != nullptr) {
return node->next != nullptr && node->next->next != nullptr
&& node->next != this->_tail && node->next->next != this->_tail;
}
return false;
}
The checks for this->_tail are only for if your this->_tail is not to be considered part of the list, but if it is, then you can safely remove those.
Now what you can do is that if you pass in an even node, it will tell you if that node can reach the next even one or not. Once this function returns false for any of the chains you are twisting, that is when you know it is time to stop.
Be careful of nulls.