Question

I’m looking for an algorithm to generate permutations of a set in such a way that I could make a lazy list of them in Clojure. i.e. I’d like to iterate over a list of permutations where each permutation is not calculated until I request it, and all of the permutations don’t have to be stored in memory at once.

Alternatively I’m looking for an algorithm where given a certain set, it will return the ‘next’ permutation of that set, in such a way that repeatedly calling the function on its own output will cycle through all permutations of the original set, in some order (what the order is doesn’t matter).

Is there such an algorithm? Most of the permutation-generating algorithms I’ve seen tend to generate them all at once (usually recursively), which doesn’t scale to very large sets. An implementation in Clojure (or another functional language) would be helpful but I can figure it out from pseudocode.

Answer 1

Yes, there is a ‘next permutation’ algorithm, and it’s quite simple too. The C++ standard template library (STL) even has a function called next_permutation.

The algorithm actually finds the next permutation — the lexicographically next one. The idea is this: suppose you are given a sequence, say ‘32541’. What is the next permutation?

If you think about it, you’ll see that it is ‘34125’. And your thoughts were probably something this: In ‘32541’,

• there is no way to keep the ’32’ fixed and find a later permutation in the ‘541’ part, because that permutation is already the last one for 5,4, and 1 — it is sorted in decreasing order.
• So you’ll have to change the ‘2’ to something bigger — in fact, to the smallest number bigger than it in the ‘541’ part, namely 4.
• Now, once you’ve decided that the permutation will start as ’34’, the rest of the numbers should be in increasing order, so the answer is ‘34125’.

The algorithm is to implement precisely that line of reasoning:

1. Find the longest ‘tail’ that is ordered in decreasing order. (The ‘541’ part.)
2. Change the number just before the tail (the ‘2’) to the smallest number bigger than it in the tail (the 4).
3. Sort the tail in increasing order.

You can do (1.) efficiently by starting at the end and going backwards as long as the previous element is not smaller than the current element. You can do (2.) by just swapping the ‘4’ with the ‘2’, so you’ll have ‘34521’. Once you do this, you can avoid using a sorting algorithm for (3.), because the tail was, and is still (think about this), sorted in decreasing order, so it only needs to be reversed.

The C++ code does precisely this (look at the source in /usr/include/c++/4.0.0/bits/stl_algo.h on your system, or see this article); it should be simple to translate it to your language: [Read ‘BidirectionalIterator’ as ‘pointer’, if you’re unfamiliar with C++ iterators. The code returns false if there is no next permutation, i.e. we are already in decreasing order.]

template <class BidirectionalIterator> bool next_permutation(BidirectionalIterator first,                       BidirectionalIterator last) {     if (first == last) return false;     BidirectionalIterator i = first;     ++i;     if (i == last) return false;     i = last;     --i;     for(;;) {         BidirectionalIterator ii = i--;         if (*i <*ii) {             BidirectionalIterator j = last;             while (!(*i <*--j));             iter_swap(i, j);             reverse(ii, last);             return true;         }         if (i == first) {             reverse(first, last);             return false;         }     } } 

It might seem that it can take O(n) time per permutation, but if you think about it more carefully, you can prove that it takes O(n!) time for all permutations in total, so only O(1) — constant time — per permutation.

The good thing is that the algorithm works even when you have a sequence with repeated elements: with, say, ‘232254421’, it would find the tail as ‘54421’, swap the ‘2’ and ‘4’ (so ‘232454221’), reverse the rest, giving ‘232412245’, which is the next permutation.