Heap's algorithm in C++ repeating? - c++

Question

I am trying to implement Heap's algorithm in C++.
However, the algorithm starts to repeat if the string it's permuting gets to a length of 4. Here's the code:
void permute(int n, string str, int *total,string array[]){
if (n==0){
array[*total] = str;
*total += 1;
}
else{
for(int c=0; c<=n;c++){
permute(n-1,str,total, array);
if (n % 2 == 0){
char tmpstr=str[c];
str[c]=str[n];
str[n]=tmpstr;
}
else{
char tmpstr=str[0];
str[0]=str[n];
str[n]=tmpstr;
}
}
}
}
int main() {
int total = 0;
string array[24];
permute(3,"abcd",&total, array);
cout << total << endl;
return 0;
}
And here is the output. It repeats at the 13th line
24
abcd
bacd
cbad
bcad
cabd
acbd
dbca
bdca
cbda
bcda
cdba
dcba
abcd <-- right here
bacd
cbad
bcad
cabd
acbd
dbca
bdca
cbda
bcda
cdba
dcba
Thank you guys and any help is welcome!

Answer 1

While it is always an excellent idea to use the standard function recommended by PaulMcKenzie, you have posted a code with a question about why it doesn't work.
In your for loop, get rid of the line if (n%2 ==0) and its else part:
for(int c=0; c<=n;c++){
permute(n-1,str,total, array);
char tmpstr=str[c];
str[c]=str[n];
str[n]=tmpstr;
}
It should then work.

Answer 2

It looks like you are trying to implement the recursive version of the Heap's algorithm for permutation generation stated in wikipedia and originally given in here. If you want to stay close to it (for example, to have the same order when generating the permutations), all you have to do is pass the str parameter as a reference (you'll have to change the line calling the permute() function to pass a mutable string instead a string constant, tough) and keep the if-then-else clause originally in your program.
Nevertheless, it is interesting the version given by #Christophe. I've tried it with up to n=6 (permutations of 7 elements), and still give all permutations. It'd be interesting to know if this can be proved to hold for any natural number. This point may be moot, however, since the recursive version given in the two references I cited does not implement the original version given by Heap, either, and, as far as I know, hasn't been proved to give all permutations either. The original version given by Heap, written in 1963, did not even use structured programming. It was given as a flowgraph to be implemented with goto's.

Answer 3

Here, have my implementations of recursive and iterative versions:
//recursive
int perm_num = 0;
void heappermute(int v[], int n) {
int i;
if (n == 1) {
//print(v);
++perm_num;
}
else {
for (i = 0; i < n; i++) {
heappermute(v, n - 1);
if (n % 2 == 1) {
swap(&v[0], &v[n - 1]);
}
else {
swap(&v[i], &v[n - 1]);
}
}
}
}
int perm_num_iter = 0;
void heappermuteiterative(int v[], int n) {
int c[30];
for (int i = 0; i <= n; ++i) {
c[i] = 0;
}
++perm_num_iter;
//print(v);
int i = 1;
while (i < n) {
if (c[i] < i) {
if (i % 2 == 0) {
swap(&v[0], &v[i]); // or i-1
}
else {
swap(&v[c[i]], &v[i]); // or i-1
}
++perm_num_iter;
//print(v);
++c[i];
i = 1;
}
else {
c[i] = 0;
++i;
}
}
}
I copied the recursive one from somewhere on the net, and the iterative one is the Wikipedia's one written in C.