runner technique for weaving elements of linked list - c++

Question

I've been reading the cracking the coding interview book. I am a bit stuck on implementing the runner technique for weaving elements of a linked list. The book goes as follows:
"Suppose you had a linked list a1->a2....->an->b1->b2....bn, and you want to rearrange it into a1->b1->a2->b2->.....an->bn. You don't know the length of the linked list but all you know is that it is an even number.
You could have one pointer p1 (fast pointer) move every two elements for every one move that p2 makes. When p1 hits the end of the linked list, p2 will be at the endpoint. Then, move p1 back to the front and begin "weaving" the elements. On each iteration, p2 selects an element and inserts it after p1."
Now I understand the technique up to the point before weaving starts. So, right before weaving, we basically have (for n=4 elements)
p1 p2
a1->a2->b1->b2
Now, if I understand correctly, I have to move the element pointed to by p2 (i.e. b1) and insert it after p1, in other words
p1.next = p2
which would result in the following list (?)
a1->b1->b2
How does the algorithm proceed from here?
I found this question but it seems to suggest that the above step would result in
a1->b1->a2->b2
which I do not see how. I am probably missing something fundamental here.

Answer 1

If A1 -> A2 -> ... -> AN -> B1 -> B2 ... -> BN is your original linked list, after the first step you'll have P1 and P2 pointing at A1 and B1 respectively. Let's say AN points to null, this can be done easily in the first step.
At each iteration, do these steps:
temp1 = P1.next
temp2 = P2.next //1
P2.next = P1.next //2
P1.next = P2 //3
P1 = temp1
P2 = temp2 //4
Here are the changes at the four positions in the first iteration:
1:
P1 P2
⬍ ⬍
A1 → A2 → ... → AN B1 → B2 ... → BN
⬍ ⬍
temp1 temp2
2:
P1 .–––––––––––––––.
⬍ ↓ ↑
A1 → A2 → ... → AN B1 B2 ... → BN
⬍ ⬍ ⬍
temp1 P2 temp2
3:
P1 .–––––––––––––––.
⬍ ↓ ↑
A1 A2 → ... → AN B1 B2 ... → BN //P2 points on B1
↓ ⬍ ↑ ⬍
↓ temp1 ↑ temp2
·––––––––––––––––––––·
This is equivalent to:
P1 P2
⬍ ⬍
A1 → B1 → A2 → ... → AN B2 ... → BN
⬍ ⬍
temp1 temp2
4:
P1 P2
⬍ ⬍
A1 → B1 → A2 → ... → AN B2 ... → BN
⬍ ⬍
temp1 temp2
And you repeat the same until P1 reaches AN.

Answer 2

The algorithms presented by Adam Stelmaszczyk, Igor Tandetnik and four_lines are correct; one only has to take care with the terminating condition otherwise the final nullptr that terminates the list can become lost. four_lines advocates handling this before doing the weaving. Or it can be done during the weaving by checking:
#include "stdafx.h"
#include <iostream>
namespace
{
struct elem
{
int val;
elem* next;
elem() : val(-1), next(nullptr) {}
};
}
int main()
{
// setup single-linked list of elements (an array here makes it easy...)
const int SIZE = 12; // even number
elem elems[SIZE];
for (int x = 0; x < SIZE - 1; ++x) { elems[x].next = &elems[x + 1]; }
for (int x = 0; x < SIZE; ++x) { elems[x].val = x; }
// divide the list using ptrs pf, ps to point at first part, second part
elem* pf = elems;
elem* ps = elems;
do
{
pf = pf->next;
pf = pf->next;
ps = ps->next;
} while (pf != nullptr);
pf = elems; // move pf back to start
// weave first and second parts of list using pf and ps
do
{
// update pf element next-ptr to point at ps, then move pf to its original next element
elem* oldpfnext = pf->next;
pf->next = ps;
pf = oldpfnext;
// if ps element is not at end, update ps element next-ptr to point the new location of pf
elem* oldpsnext = ps->next;
if (nullptr != ps->next)
{
ps->next = pf;
}
// now move ps to its original next element (even if null)...
ps = oldpsnext;
} while (nullptr != ps); // ... and stop if we are now at end
return 0;
}