填充红黑树的最有效方法是什么?

What is the most efficient way to populate a red black tree?

本文关键字：有效 方法 是什么 填充      更新时间：2023-10-16

假设我知道关于某些数据集的所有信息以及它进入的控制顺序 - 将其组织成红色黑色树的最有效方法是什么？

或者，在流行的std::set/map实现(基于"红黑树")的上下文中，使用上述数据集填充std::set的最有效方法是什么？

在回答之前，请考虑以下事项：

  • afaik，红黑树有便宜的O(1)(正确提示)插入...除非树深度突破一定的限制，在这种情况下，它将被重新平衡(以O(log N)成本)——就像在std::vector::push_back()的情况下，我们最终得到摊销的常数复杂性

  • 例如，如果数据集是一个值列表[0,999]，则应该有一系列永远不会触发重新平衡的提示插入(即保持每个插入O(1))。

非常微不足道的例子(需要弄清楚如何选择这些 YYY/ZZZ 值)：

std::set<int> s;
std::vector< std::set<int>::iterator > helper(1000);
helper[0] = s.insert(0);
helper[1] = s.insert(helper[0], 1);
//...
helper[500] = s.insert(helper[YYY], 500);
//...
helper[999] = s.insert(helper[ZZZ], 999);

我在寻找什么：

  1. 一种算法，允许我用(特别是)准备好的(任意长)序列填充(基于"红黑树")std::set，其中每个插入都保证 O(1)

  2. 应该有一种方法可以减少额外的内存需求(即helper的大小)或理想情况下消除对它的需求

  3. 一种在最坏情况下填充树的算法(以了解传入的数据集不应该是什么样子)——当我们最终得到最大可能的rebalance事件数时就是这种情况

  4. 奖励目标是获得基于"AVL 树"的问题 1-3 的答案std::set

谢谢

找到一种不需要额外内存且适用于任何二叉搜索树(红黑/AVL/等)的算法：

  1. 用于表示"扁平化"二叉树的传入数据数组(根位于 [0]，根子节点位于 [1] 和 [2]，左节点子节点位于 [3] 和 [4]，右节点子节点位于 [5] 和 [6] 等)。诀窍是选择每个子树的根，这样生成的二叉树就填充了每个lvl(但最后一个)，并且在最后一层，所有节点都形成一条"不间断"的线。喜欢这个：

    N11
/     
N21      N22
/       /
N31 N32 N33

请参阅下面的代码，了解如何将排序后的数组转换为此类序列。我相信对于任何序列，只有一种可能的方法可以在这样的二叉搜索树中排列它 - 即你最终在这里得到某种"稳定性"保证(对于给定的序列长度，我们确切地知道每个元素将在树中结束的位置)。

  1. 然后对数据执行一次传递并逐级填充树。在每个级别，我们确切地知道在切换到下一个 lvl(或数据耗尽)之前要拉多少个元素(2^(lvl-1))。在每次迭代开始时，我们将位置重置为最左侧的元素(std::set<T>::begin())，在插入左右子元素后，我们移动到当前级别的下一个叶子(从上次insert()调用的结果开始双++it)。

笔记：

  • 具有std::set<int>性能优势(与排序序列的提示插入相比为 5-10%)

  • 不幸的是，MS 红黑树实现最终在这里执行了许多不必要的工作——检查相邻元素(以确保插入不会破坏二叉树不变性)、重新绘制节点(由于某种原因新插入的节点总是红色)以及可能的其他内容。检查邻居涉及额外的比较和内存访问，以及遍历树的多个级别

  • 如果这种方法在内部实现(不使用std::set公共接口)作为一个函数，期望数据符合要求，如果不是，则声明"未定义的行为"，那么这种方法的好处会高得多......

  • 。在这种情况下，更好的算法将填充树深度优先，并要求以不同的方式重新排列输入数据([N11, N21, N31, N32, N22, N33]在上面的示例中)。我们最终也只会做一棵树遍历......唉，但是，无法使用std::set公共接口来实现这种方法 - 它将在构建的每一步强制执行红黑树不变性，从而导致不必要的重新平衡

代码：(MSVC 2015，原谅马铃薯质量 - 它写在膝盖上大约一个小时)

#include <set>
#include <cassert>
#include <vector>
#include <utility>
#include <chrono>
#include <cstdio>

using namespace std;

unsigned hibit(size_t n)
{
unsigned long l;
auto r = _BitScanReverse(&l, n);
assert(r);
return l;
}

int const* pick_root(int const* begin, int const* end)
{
assert(begin != end);
size_t count = end - begin;
unsigned tree_order = hibit(count);         // tree height minus 1
size_t max_tail_sz = 1 << tree_order;       // max number of nodes on last tree lvl
size_t filled_sz = max_tail_sz - 1;         // number of nodes on all but last tree lvl
size_t tail_sz = count - filled_sz;         // number of nodes on last lvl
return (tail_sz >= max_tail_sz/2) ?         // left half of tree will be completely filled?
begin + max_tail_sz - 1                 // pick (2^tree_order)'s element from left
:
end - max_tail_sz/2;                    // pick (2^(tree_order - 1))'s element from right
}

vector<int> repack(vector<int> const& v)
{
vector<int> r; r.reserve(v.size());
if (!v.empty())
{
unsigned tree_order = hibit(v.size());  // tree height minus 1
vector<pair<int const*, int const*>> ranges(1, make_pair(&v[0], &v[0] + v.size()));
for(size_t i = 0; i <= tree_order; ++i)
{
vector<pair<int const*, int const*>> ranges2; ranges2.reserve(ranges.size()*2);
for(auto const& range: ranges)
{
auto root = pick_root(range.first, range.second);
r.push_back(*root);
if (root != range.first)
{
ranges2.push_back(make_pair(range.first, root));
if (root + 1 != range.second)
ranges2.push_back(make_pair(root + 1, range.second));
}
}
ranges.swap(ranges2);
}
assert(ranges.empty());
}
return r;
}

set<int> populate_simple(std::vector<int> const& vec)
{
set<int> r;
for(auto v: vec) r.insert(v);
return r;
}

set<int> populate_hinted(std::vector<int> const& vec)
{
set<int> r;
for(auto v: vec) r.insert(r.end(), v);
return r;
}

set<int> populate_optimized(std::vector<int> const& vec)
{
set<int> r;
if (vec.empty()) return r;
int const* p = &vec[0];
int const* pend = &vec[0] + vec.size();
r.insert(*p++);                   // take care of root
if (p == pend) return r;
for(size_t count = 1; ; count *= 2) // max number of pairs on each tree lvl
{
auto pos = r.begin();
for(size_t i = 1; ; ++i)
{
r.insert(pos, *p++);
if (p == pend) return r;
//++pos;            // MS implementation supports insertion after hint
pos = r.insert(pos, *p++);
if (p == pend) return r;
// pos points to rightmost leaf of left subtree of "local" tree
++pos;          // pos points to root of "local" tree (or end())
if (i == count) break;
++pos;      // pos points to leftmost leaf of right subtree of "local" tree
}
}
}

struct stopwatch
{
chrono::high_resolution_clock::time_point start_;
stopwatch() : start_(std::chrono::high_resolution_clock::now()) {}
auto click()
{
auto finish = std::chrono::high_resolution_clock::now();
auto mks = std::chrono::duration_cast<std::chrono::microseconds>(finish - start_);
return mks.count();
}
};

int main()
{
size_t N = 100000;
vector<int> v(N, 0);
for(unsigned i = 0; i < N; ++i) v[i] = i;   // sorted array
auto rv = repack(v);
{
stopwatch w;
auto s = populate_simple(v);
printf("simple   : %I64d mksn", w.click());
}
{
stopwatch w;
auto s = populate_hinted(v);
printf("hinted   : %I64d mksn", w.click());
}
{
stopwatch w;
auto s = populate_optimized(rv);
printf("optimized: %I64d mksn", w.click());
}
return 0;
}

典型结果：

simple   : 14904 mks
hinted   : 7885 mks
optimized: 6809 mks
simple   : 15288 mks
hinted   : 7415 mks
optimized: 6947 mks

我很确定测量并不完全准确，但关系始终存在 - 优化版本总是更快。另外，请注意，用于重新排列元素的算法可能会得到改进 - 目的是优化树种群(而不是输入数据准备)。

首先，对输入进行排序。

理想的情况是将排序后的输入放入一个平衡的二叉树中，但假装它在树中是可以的;它只需要更多的簿记。它实际上不一定是真正的树数据结构;您可以使用根为元素 0，元素 i 的子元素位于 2i+1 和 2i+2 的数组。在任何情况下，树都可以递归构建。

一旦你有了原始数据的平衡二叉树，你需要将其复制到集合中，而不会产生任何重新平衡。为此，请对树进行广度优先扫描(如果您使用上面提到的数组，这只是阵列的顺序扫描，这使得此步骤非常简单)。您可以在 BFS 中保存每个关卡的插入点，以便获得下一个关卡的提示(因此您需要能够将迭代器保持在树的一半左右)，但是在构建集合时遍历集合会更容易，而且可能更快，从每个关卡的开头开始， 否则，每次插入后前进两个元素。

这些都不比按顺序构建集合更快。但这是问题的答案。

对于最差的提示插入填充，请按反向排序顺序插入元素，用前一个插入点的插入点提示每个插入。

我认为相同的算法也适用于 AVL 树。

相关文章：