Josephus Election Problem array implementation - c++

Question

I am trying to implement the Josephus election problem using an array as a mock circular linkedlist.
The item and next arrays represent nodes for circular linked list. On every Mth element one element is marked for removal. The next array skips over the marked index.
When there is one element left in the array we print out the element and the item that is left.
The problem is from Sedgewick C++ Algorithms books Chapter Third Edition. exercise 3.31.
The output I am getting is incorrect, I am not lost.
void array_represent_linked_list(int num_ints, int M) {
int* item = new int[num_ints];
int* next = new int[num_ints];
//populated item and next array with elements
for (int index = 0; index < num_ints; index++) {
item[index] = index + 1;
if (index == (num_ints - 1)) {
next[index] = 0;
}
else {
next[index] = index + 1;
}
}
int nums_left = num_ints;
int x = 0;
int count = 0;
int last_element_index = 0;
while ( nums_left > 1) {
//if current value divisible by M-2?
if ((count % M-2) == 0) {
if ((nums_left - 1) == 1) {
//record the next index which is the last element
last_element_index = next[x];
}
else {
//mark for removal of element from array
next[x] = next[next[x]];
}
nums_left -= 1;
}
//move to next element of array
x = next[x];
count++;
}
std::cout << item[last_element_index]<< " " << last_element_index<< std::endl;
}
output for
array_represent_linked_list(9,5); //item[x] =8 , next[x] = 7

Answer 1

After writing a brute force method which looks at each individual element in the item array and setting each element to 0 when we reach a skip factor of M. I was able to test with this code snippet and get the correct answers.
Breaking down the problem, every M-1 elements should set the next[index] to next[next[index]] , and we traverse the array with x = next[x].
void array_represent_linked_list(int num_ints, int M) {
int* item = new int[num_ints];
int* next = new int[num_ints];
//populated item and next array with elements
for (int index = 0; index < num_ints; index++) {
item[index] = index + 1;
if (index == (num_ints - 1)) {
next[index] = 0;
}
else {
next[index] = index + 1;
}
}
int nums_left = num_ints;
//used to track elements in item array
int index = 0;
//used to count number of elemenets traversed in the list
int count = 0;
//store the return values
int return_index = 0;
int return_val = 0;
while (nums_left > 1) {
count += 1;
if (count == (M - 1)) {
//reset the count after reaching 4 elements
count = 0;
//update next element
next[index] = next[next[index]];
//decrease nums found
nums_left -= 1;
}
//traverse to next element
index = next[index];
}
return_index = index;
return_val = item[next[index]];
std::cout << return_index << " " << return_val << std::endl;
}

Answer 2

The book gives a linked list implementation similar to the following:
struct node {
int item;
node* next;
node(int x, node* t) {
item = x;
next = t;
}
};
typedef node *link;
int josephusLinkedList(int n, int k) {
link t = new node(1, 0);
t->next = t;
link x = t;
for (int i = 2; i <= n; i++) {
x = (x->next = new node(i, t));
}
while (x != x->next) {
for (int i = 1; i < k; i++) x = x->next;
x->next = x->next->next;
}
return x->item;
}
We can write a very similar implementation that simulates the linked list using an array next where the index of the array represents the node and the value represents the pointer to the next node.
int josephusArray(int n, int k) {
int *next = new int[n];
for (int i = 0; i < n; i++) {
next[i] = (i + 1) % n;
}
int x = 0;
while (x != next[x]) {
for (int j = 1; j < k; j++) x = next[x];
next[x] = next[next[x]];
}
return x;
}
We initialize the next array by setting each value to the next index, until we reach the end, which we set to 0, the first index. This simulates the circular linked list that is the starting condition of the problem.
The while loop then eliminates every kth element by advancing through the next array k-1 times, then "removing" the next element by setting next[x] = next[next[x]];, which is very similar to how we remove an element from a linked list. (The element isn't really removed from the array, but it will be skipped in future traversals because no value will point to that element.)