C ++递归生成集合的排列

Question

I've been assigned the task of writing a C++ function that returns all possible permutations from a group of integers. I've done a bit of research but all algorithms I find show the permutation being printed out.

The problem I'm running in to is I don't know how to set up the function, specifically, how I should handle receiving data from recursive calls. My first guess was to use a linked list, but I know if I try to return a pointer to a Node I'll end up with a pointer to invalid memory.

My other guess was to use some sort of global linked list of vectors, but I can't imagine how I could add to the linked list from a function itself. Further, this is more sidestepping the problem than actually solving it, and I'd like to actually solve it if at all possible.

As this is a homework problem, I don't expect anyone to hand me an answer outright. I'm just lost and would greatly appreciate someone pointing me in the right direction.

Answer 1

You could use std::next_permutation . It operates on the data structure so you can do anything you want with the data structure after each iteration.

If you're implementing your own permutation logic, suppose you're operating on vector<int>& data , you could add a parameter like vector<vector<int> >& result in your recursive function. Each time a permutation is generated you could simply do result.push_back(data) .

Answer 2

One possible approach: store the set in an array, then call a function giving it an array (a ptr to the first item) and the array length as parameters. Make sure the array is initially sorted, say in ascending order, then reorder it to a 'lexically next' permutation on each call.

Answer 3

You can use next_permutation and accumulate copies of all the permutations:

template<class T>
vector<vector<T>> permutations(vector<T> input) {
  vector<vector<T>> result{input};
  while (next_permutation(begin(input), end(input)))
    result.push_back(input);
  return result;
}

Since this is a homework problem, I expect you have to generate the permutations yourself. But this points to an approach—have an accumulator of type vector<vector<T>> , and pass it as a reference parameter to the recursive version of your algorithm:

template<class T>
vector<vector<T>> permutations(const vector<T>& input) {
  vector<vector<T>> output;
  collect_permutations(input, output);
  return output;
}

template<class T>
void collect_permutations(const vector<T>& input, vector<vector<T>>& output) {
  // Instead of printing, simply write to output using push_back() etc.
}

Answer 4

If you in fact want just the combinations (order of the items in the returned set doesn't matter), then I would use the binary counter approach - for a source set of N items, define an N-bit binary counter and count from 0 to 2^N-1 - each bit in the counter corresponds to one of the N items, and each number represents a combination where only the items that have a 1 bit are present in the combination.

For permutations, you would then have to generate all possible orderings of the items in each individual combination, along with some way to eliminate duplicates if necessary.