Question

让我们假设给定的多集，例如

A = {1, 1, 1, 2, 2, 3, 3, 3}.

对这样的元素进行排序的最简单方法是什么：

(1, 2, 3, 1, 2, 3, 1, 3),

即。从由集合的可用元素构建的升序子序列构建的序列？

如何在C ++和Python中实现。那有没有图书馆？怎么做“手工”？

Answer 1

您可以将其实现为Counting sort 首先计算每个元素出现的次数，element是数组中的索引，用于存储每个值的出现次数。然后遍历该数组，直到每个索引的值为零。

这可能不是实现它的最佳（或最有效）方式，但这是首先想到的解决方案。

Answer 2

假设您愿意修改原始的multiset，（或处理它的副本），请执行类似

的操作

while(!data.empty()) {
    auto x = data.begin();
    while( x != data.end()) {
        auto value = *x;
        cout << value << endl;
        data.erase(x); // delete *one* item
        x = data.upper_bound(value); // find the next *different* value
    }
}

效率不高。如果你有一个庞大的数据集，那么你可能需要考虑你的约束是什么（记忆或时间？）。

Answer 3

在Python中，您可以使用groupby从排序列表中获取唯一项目组的矩阵：

from itertools import groupby, izip_longest

A=[1, 1, 1, 2, 2, 3, 3, 3]

groups=[]
for k, g in groupby(sorted(A)):
    groups.append(list(g))

print groups
# [[1, 1, 1], [2, 2], [3, 3, 3]]

更简洁地说，你可以使用列表理解来做同样的事情：

groups=[list(g) for _, g in groupby(sorted(A))]
# [[1, 1, 1], [2, 2], [3, 3, 3]]

或者，您可以扩展多重集的Python版本Counter，并对键进行排序以获得相同的嵌套列表：

from collections import Counter
c=Counter(A)
groups=[[k]*c[k] for k in sorted(c.keys())]
# [[1, 1, 1], [2, 2], [3, 3, 3]]

获得嵌套列表groups后，使用izip_longest反转矩阵，展平列表，并删除None值：

print [e for t in izip_longest(*groups) for e in t if e!=None]

打印

[1, 2, 3, 1, 2, 3, 1, 3]

Answer 4

以下是如何在没有任何导入库的情况下手动执行：

A = (1, 1, 1, 2, 2, 3, 3, 3)

# create a list out of a set of unique elems in A
a = list(set(A))
a.sort() # sort so they are in ascending order

countList = []

# find how many repeated elems in the list set we just made
for i, elem in enumerate(a, 0):
    countList.append(A.count(elem))

# find the what is the lowest repeated number in the orig list
minEntry = min(countList)
# we can multiply the list set by that lowest number
outString = a * minEntry

# add the left over numbers to the outstring
for i in range(len(countList)):
    count = abs(countList[i] - minEntry)
    if count != 0:
        outString.append(a[i]*count)

print outString

这是outputString

[1, 2, 3, 1, 2, 3, 1, 3]

Answer 5

如果你可以使用第二个sequantial容器，那么在C ++中你可以通过标准算法std :: unique_copy和std :: set_difference简单地在第二个容器中移动原始容器的元素。

Answer 6

def Test(seq):
    index = 0
    Seq = seq
    newlist = []
    while len(Seq) != 0:
            newlist.append(list(set(Seq).union()))
            for Del in newlist[index]:
                    Seq.remove(Del)
            index += 1
    return [y for x in newlist for y in x]

Answer 7

在C ++中，您可以准备一个迭代器列表到相等范围的开头，而不是操纵数据结构，然后依次取消引用/递增这些迭代器：

#include <set>
#include <list>
#include <iostream>

int main()
{
    std::multiset<int> A = {1, 1, 1, 2, 2, 3, 3, 3};

    // build a list of iterator pairs to each equal range
    std::list< std::pair<std::multiset<int>::iterator,
                         std::multiset<int>::iterator> > iters;
    for(auto it=A.begin(); it != A.end(); it = A.upper_bound(*it))
        iters.push_back(A.equal_range(*it));

    // for each non-empty subrange, show what the first iterator is
    // pointing to, then advance it by one position in its subrange
    // if the subrange is empty, drop it from the list
    while(!iters.empty())
        for(auto it = iters.begin(); it != iters.end(); )
            if(it->first != it->second)
               std::cout << *it++->first++ << ' '; // don't do this at home
            else
               it = iters.erase(it);
}

将multiset排序为升序子序列，每个可用元素出现一次

7 个答案: