Question

我很好奇std:next_permutation是如何实现的，因此我提取了gnu libstdc++ 4.7版本并清理了标识符和格式以生成以下演示...

#include <vector>
#include <iostream>
#include <algorithm>

using namespace std;

template<typename It>
bool next_permutation(It begin, It end)
{
        if (begin == end)
                return false;

        It i = begin;
        ++i;
        if (i == end)
                return false;

        i = end;
        --i;

        while (true)
        {
                It j = i;
                --i;

                if (*i < *j)
                {
                        It k = end;

                        while (!(*i < *--k))
                                /* pass */;

                        iter_swap(i, k);
                        reverse(j, end);
                        return true;
                }

                if (i == begin)
                {
                        reverse(begin, end);
                        return false;
                }
        }
}

int main()
{
        vector<int> v = { 1, 2, 3, 4 };

        do
        {
                for (int i = 0; i < 4; i++)
                {
                        cout << v[i] << " ";
                }
                cout << endl;
        }
        while (::next_permutation(v.begin(), v.end()));
}

输出符合预期：http://ideone.com/4nZdx

我的问题是：它是如何运作的？ i，j和k的含义是什么？他们在执行的不同部分有什么价值？什么是正确性证明的草图？

显然，在进入主循环之前，它只检查普通的0或1元素列表情况。在主循环的入口处，我指向最后一个元素（不是一个过去的结尾），列表至少有2个元素。

主循环体内发生了什么？

Answer 1

让我们看看一些排列：

我们如何从一个排列变为另一个排列？首先，让我们看看事情有点不同。 我们可以将元素视为数字，将排列视为数字。以这种方式查看问题我们希望以“升序”顺序排列排列/数字。

当我们订购数字时，我们希望“以最小的数量增加它们”。例如，当计数我们不计数1,2,3,10，...因为它们之间仍然有4,5，...，虽然10大于3，但是有缺失的数字可以通过以较小的数量增加3。在上面的示例中，我们看到1长时间保留为第一个数字，因为最后3个“数字”的重新排序很多，这会使排列“增加”一个较小的数量。

那么我们何时最终“使用”1？当最后3位数字没有更多排列时什么时候没有更多的最后3位数的排列？当最后3位数字按降序排列时。

啊哈！这是理解算法的关键。 我们只更改“数字”的位置，当右边的所有内容都按降序 时，因为如果它不按降序排列，那么还有更多的排列 （即我们可以将排列量“增加”一小部分）。

现在让我们回到代码：

while (true)
{
    It j = i;
    --i;

    if (*i < *j)
    { // ...
    }

    if (i == begin)
    { // ...
    }
}

从循环的前两行开始，j是一个元素，i是它之前的元素。
然后，如果元素按升序排列，（{{1做某事。
否则，如果整个事件按降序排列，（if (*i < *j)）则这是最后一个排列。
否则，我们继续，我们看到j和i基本上是递减的。

我们现在了解if (i == begin)部分，因此我们需要了解的是if (i == begin)部分。

另请注意：“那么如果元素按升序排列......”这支持了我们之前的观察，即当“右边的所有内容按降序排列”时，我们只需要对数字执行某些操作。升序if (*i < *j)语句基本上是找到最左边的位置，“右边的所有内容都按降序排列”。

让我们再看一些例子：

if

我们看到当数字右侧的所有内容都按降序排列时，我们找到下一个最大的数字并将其放在前面，然后将其余数字按升序排列< /强>

让我们看一下代码：

... 1 4 3 2 2 1 3 4 ... 2 4 3 1 3 1 2 4 ...

好吧，因为右边的东西按降序排列，要找到“下一个最大的数字”，我们只需要从最后一步迭代，我们在前3行代码中看到。

接下来，我们使用It k = end; while (!(*i < *--k)) /* pass */; iter_swap(i, k); reverse(j, end); return true;语句将“下一个最大数字”交换到前面，然后由于我们知道数字是下一个最大数字，我们知道右边的数字仍然是降序，所以要按升序排列，我们只需要iter_swap()它。

Answer 2

gcc实现按字典顺序生成排列。 Wikipedia解释如下：

以下算法生成下一个排列   在给定的排列之后按字典顺序排列。它改变了给定的   就地排列。


找到最大的索引k，使得a [k]＆lt; a [k + 1]。如果没有这样的指数   存在，排列是最后的排列。

找到最大的索引l，使得a [k]＆lt;一个[1]。由于k + 1是这样的指数，所以l是   明确定义并满足k <湖

用[l]交换[k]。

将序列从[k + 1]反转到最后一个元素a [n]。

Answer 3

Knuth深入探讨了该算法及其在计算机编程艺术的7.2.1.2和7.2.1.3节中的概括。他称之为“算法L” - 显然它可以追溯到13世纪。

Answer 4

这是使用其他标准库算法的完整实现：

template <typename I, typename C>
    // requires BidirectionalIterator<I> && Compare<C>
bool my_next_permutation(I begin, I end, C comp) {
    auto rbegin = std::make_reverse_iterator(end);
    auto rend = std::make_reverse_iterator(begin);
    auto next_unsorted = std::is_sorted_until(rbegin, rend, comp);
    bool at_final_permutation = (next_unsorted == rend);
    if (!at_final_permutation) {
        auto next_permutation = std::upper_bound(
            rbegin, next_unsorted, *next_unsorted, comp);
        std::iter_swap(next_unsorted, next_permutation);
    }
    std::reverse(rbegin, next_unsorted);
    return !at_final_permutation;
}

Demo

Answer 5

使用<algorithm>在cppreference上有一个自我解释的可能的实现。

template <class Iterator>
bool next_permutation(Iterator first, Iterator last) {
    if (first == last) return false;
    Iterator i = last;
    if (first == --i) return false;
    while (1) {
        Iterator i1 = i, i2;
        if (*--i < *i1) {
            i2 = last;
            while (!(*i < *--i2));
            std::iter_swap(i, i2);
            std::reverse(i1, last);
            return true;
        }
        if (i == first) {
            std::reverse(first, last);
            return false;
        }
    }
}

将内容更改为按字典顺序排列下一个排列（就地），如果存在则返回true，否则排序，如果不存在则返回false。

std :: next_permutation实现说明

5 个答案: