获得std :: set中间（中位数）的有效方法？

Question

std::set 是一个排序树。它提供了begin 和end 方法，因此我可以获得最小值和最大值以及lower_bound 和upper_bound 进行二分搜索。但是，如果我想让迭代器指向中间元素（或者如果那里有偶数个元素，则其中之一）怎么办？

有没有一种有效的方法（O(log(size)) 而不是O(size)）来做到这一点？

{1} => 1
{1,2} => 1 or 2
{1,2,3} => 2
{1,2,3,4} => 2 or 3 (but in the same direction from middle as for {1,2})
{1,312,10000,14000,152333} => 10000

PS：Same question in Russian.

Answer 1

根据您插入/删除项目与查找中间/中位数的频率，一种可能比显而易见的解决方案更有效的解决方案是为中间元素保留一个持久迭代器，并在您插入/删除项目时更新它放。有一堆需要处理的边缘情况（奇数与偶数项目，删除中间项目，空集等），但基本思想是当您插入一个小于当前中间项目的项目时，您的中间迭代器可能需要递减，而如果您插入更大的迭代器，则需要递增。删除则相反。

在查找时，这当然是 O(1)，但它在每次插入/删除时也有本质上 O(1) 的成本，即 N 次插入后的 O(N)，这需要在足够的时间摊销查找次数，使其比暴力破解更有效。

Answer 2

得到二叉搜索树的中间需要 O(size) 。您可以通过std::advance() 获取它，如下所示：

std::set<int>::iterator it = s.begin();
std::advance(it, s.size() / 2);

Answer 3

这个建议是纯粹的魔法，如果有一些重复的项目会失败

根据您插入/删除项目与查找中间/中位数的频率，一种可能比显而易见的解决方案更有效的解决方案是为中间元素保留一个持久迭代器，并在您插入/删除项目时更新它放。有一堆需要处理的边缘情况（奇数与偶数项目，删除中间项目，空集等），但基本思想是当您插入一个小于当前中间项目的项目时，您的中间迭代器可能需要递减，而如果您插入更大的迭代器，则需要递增。删除则相反。

建议

1. 第一个建议是使用 std::multiset 而不是 std::set，这样当项目可以复制时它可以很好地工作
2. 我的建议是使用 2 个多组来跟踪较小的药水和较大的药水并平衡它们之间的大小

算法

1。保持集合平衡，因此 size_of_small==size_of_big 或 size_of_small + 1 == size_of_big

void balance(multiset<int> &small, multiset<int> &big)
{
    while (true)
    {
        int ssmall = small.size();
        int sbig = big.size();

        if (ssmall == sbig || ssmall + 1 == sbig) break; // OK

        if (ssmall < sbig)
        {
            // big to small
            auto v = big.begin();
            small.emplace(*v);
            big.erase(v);
        }
        else 
        {
            // small to big
            auto v = small.end();
            --v;
            big.emplace(*v);
            small.erase(v);
        }
    }
}

2。如果集合是平衡的，则中项始终是大集合中的第一项

auto medium = big.begin();
cout << *medium << endl;

3。添加新项目时要小心

auto v = big.begin();
if (v != big.end() && new_item > *v)
    big.emplace(new_item );
else
    small.emplace(new_item );

balance(small, big);

复杂性解释

• 找到中间值是 O(1)
• 添加一个新项目需要 O(log n)
• 你仍然可以在 O(log n) 中搜索一个项目，但你需要搜索 2 个集合

Answer 4

请注意std::set 不存储重复值。如果您插入以下值{1, 2, 3, 3, 3, 3, 3, 3, 3}，您将检索到的中位数是2。

std::set<int>::iterator it = s.begin();
std::advance(it, s.size() / 2);
int median = *it;

如果您想在考虑中位数时包含重复项，您可以使用std::multiset（{1, 2, 3, 3, 3, 3, 3, 3, 3} 中位数将是3）：

std::multiset<int>::iterator it = s.begin();
std::advance(it, s.size() / 2);
int median = *it;

如果您希望对数据进行排序的唯一原因是获取中位数，那么在我看来，您最好使用普通的 std::vector + std::sort。

通过大量测试样本和多次迭代，我用std::vector 和std::sort 在5 秒内完成了测试，用std::set 或std::multiset 在13 到15 秒内完成了测试。您的里程数可能会因您拥有的重复值的大小和数量而异。

Answer 5

正如@pmdj 所说，我们使用迭代器来跟踪中间元素。下面是下面的代码实现：

class RollingMedian {
public:
multiset<int> order;
multiset<int>::iterator it;
RollingMedian() {
}

void add(int val) {
    order.insert(val);
    if (order.size() == 1) {
        it = order.begin();
    } else {
        if (val < *it and order.size() % 2 == 0) {
            --it;
        }
        if (val >= *it and order.size() % 2 != 0) {
            ++it;
        }
    }
}

double median() {
    if (order.size() % 2 != 0) {
        return double(*it);
    } else {
        auto one = *it, two = *next(it);
        return double(one + two) / 2.0;
    }
}  };

随意复制和使用此代码的任何部分。此外，如果没有重复，您可以使用 set 代替 multiset。

Answer 6

如果您的数据是静态的，您可以预先计算它而不插入新元素 - 使用 vector 、对其进行排序以及仅通过 O(1) 中的索引访问中位数会更简单

vector<int> data;
// fill data
std::sort(data.begin(), data.end());
auto median = data[data.size() / 2];