Question

我正在寻找一种方法来对一组有序元素进行分区，使得所有唯一元素在各自的重复元素之前出现，注意std::unique不适用，因为重复元素被覆盖，我想到使用{{ 3}}。调用此算法partition_unique，我还需要相应的stable_partition_unique（例如std::partition）。

partition_unique的基本实现是：

#include <algorithm>
#include <iterator>
#include <unordered_set>
#include <functional>

template <typename BidirIt, typename BinaryPredicate = std::equal_to<void>>
BidirIt partition_unique(BidirIt first, BidirIt last, BinaryPredicate p = BinaryPredicate {})
{
    using ValueTp = typename std::iterator_traits<BidirIt>::value_type;

    std::unordered_set<ValueTp, std::hash<ValueTp>, BinaryPredicate> seen {};
    seen.reserve(std::distance(first, last));

    return std::partition(first, last,
                          [&p, &seen] (const ValueTp& value) {
                              return seen.insert(value).second;
                          });
}

可以使用：

#include <vector>
#include <iostream>

int main()
{
    std::vector<int> vals {1, 1, 2, 4, 5, 5, 5, 7, 7, 9, 10};

    const auto it = partition_unique(std::begin(vals), std::end(vals));

    std::cout << "Unique values: ";
    std::copy(std::begin(vals), it, std::ostream_iterator<int> {std::cout, " "}); // Unique values: 1 10 2 4 5 9 7 
    std::cout << '\n' << "Duplicate values: ";
    std::copy(it, std::end(vals), std::ostream_iterator<int> {std::cout, " "}); // Duplicate values: 7 5 5 1
}

将stable_partition_unqiue替换为std::partition可以实现相应的std::stable_partition。

这些方法的问题在于它们不必要地缓冲std::unordered_set中的所有唯一值（这也增加了散列函数要求），这在元素排序时不应该是必需的。为partition_unique提供更好的实施并不是太多工作，但stable_partition_unique的实现似乎要困难得多，如果可能，我宁愿不stable_partition。

有没有办法使用现有算法来实现最佳partition_unique和stable_ partition_unique算法？

Answer 1

创建一个队列来保存重复项。然后，从索引1开始初始化两个索引src和dest，然后浏览列表。如果当前项（list[src]）等于上一项（list[dest-1]），则将其复制到队列中。否则，请将其复制到list[dest]并增加dest。

当您对列表用尽时，请将项目从队列中复制到原始列表的尾部。

类似的东西：

Queue dupQueue
int src = 1
int dest = 1
while (src < list.count)
{
    if (list[src] == list[dest-1])
    {
        // it's a duplicate.
        dupQueue.push(list[src])
    }
    else
    {
        list[dest] = list[src]
        ++dest
    }
    ++src
}
while (!dupQueue.IsEmpty)
{
    list[dest] = dupQueue.pop()
    ++dest
}

我知道STL有一个队列。它是否具有与上述类似的算法，我不知道。

实现partition_unique和stable_partition_unique算法

1 个答案: