替罪羊树

平衡树,是平衡的二叉排序树,精确地说,是有一定限度下的平衡。在信息学竞赛中平衡树是一个相当重点的数据结构,而绝大多数的平衡树都是需要旋转的。比如说AVL树和红黑树是两个要在节点上附带信息的带旋转平衡树,这两种平衡树效果不错,但是写起来有点麻烦(貌似AVL树有六种情况需要旋转,红黑树中的删除操作似乎有更多的旋转情况),而SBT(Size Balanced Tree,子树大小平衡树)虽然写起来挺简单的,但是仍然有所缺陷。除了这种完全宽松平衡的平衡树之外,还有像Treap和Splay两种类型,这两种类型在信息学竞赛中比较常用,Treap依赖于给节点赋上一些满足堆性质的随机值,而Splay则依赖于“伸展”操作。虽然这两种平衡树不一定完全平衡,但是对于大多数情况是够用了。虽然Splay在面对有序数据的时候会退化成链,但是在对于某些序列的动态处理问题上几乎完美。
暂且搁置掉这些数据结构,我们来考虑一下另一种平衡树。首先,我们要定义“平衡”的概念。如果一个二叉搜索树节点 x ,对于某个0.5α1满足 size(left(x))αsize(x) size(right(x))αsize(x) ,即这个节点的两棵子树包含的节点数都不超过整一棵子树的 α 倍,那么就称这个节点 x α-大小平衡的。另外,如果我们记 h(T) 为一棵树 T 的高度(即叶节点到根节点的最长链的长度),以及hα(n)=log1/αn,那么当 h(T)hα(size(T)) 的时候,我们称这棵树 T α高度平衡的。直观上讲,如果一棵树的高度不大于与这棵树同样大小的 α -权重平衡的最高的树,那么这棵树是 α -高度平衡的。从另一个角度说,一棵 α -权重平衡的树,也必然是一棵 α -高度平衡的树。实际上,替罪羊树并不是完全 α -高度平衡的,而是宽松 α -高度平衡的,也就是说,总满足 h(T)hα(size(T))+1
然后,我们先定义拍扁重建。什么是拍扁重建呢?就是将一堆节点直接重建为最平衡的二叉树,具体操作就是先将这棵子树全部“拍扁”成一个有序序列,然后递归地不断取中点为根节点,然后将剩下来的左右两端序列继续递归地重建并作为这个根节点的左右儿子。
接着,和普通的二叉搜索树一样,但是在每次操作之后都稍微检查一下,从操作的节点位置一路往上找,如果找到某一个节点满足以这个节点为根的子树不满足宽松 α -高度平衡,那么就直接拍扁重建第一个遇到的就好了(也就是直接重建深度最深的那一个)。
然后,我们来分析替罪羊树的各项修改操作的复杂度。很容易看出,我们分析时只能用均摊的方式去分析,那么这里先采用势能分析。容易发现,一个大小为 size 的子树,只有被再插入 Ω(size) 个节点的时候才会被整体地重构(即不算其孩子的单独重构)。而且,重构的代价也显然是 O(size) 的,那么当我们每插入一个节点时,就给它的所有祖先都先添上 1 的势能,那么每棵子树在重构的时候,其的根节点上就会有足够的势能去重建了,因此所有操作的均摊时间复杂度就是Ω(δ+d),其中 δ 是原本的代价,而 d 是相应的操作节点的深度。由于拍扁重建的平衡性质以及宽松α-高度平衡条件,我们同样可以证明到整棵树的高度不会超过 log1/an+1 ,那么所有基础操作(比如插入、删除、查找),就都是 Ω(logn) 的了。

这里顺便留一个小想法:Splay树的思想是否有可能和替罪羊树结合起来,使得利用一定的“部分重建”,改善Splay树的时间复杂度?替罪羊树的高度始终是不算高的,而Splay的功能却很强大,那能不能有什么方法,修改一下其的势能函数,来分析一下结合后的均摊代价呢?这样是否能够进一步地改进出一个强大的序列查找工具呢?

  • 5
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
好的,以下是用 C++ 实现替罪羊的代码。替罪羊是一种平衡二叉,可以支持插入、删除、查找等操作,并且可以在插入或删除节点时自动平衡的结构。 ```C++ #include <iostream> #include <algorithm> using namespace std; template <typename T> struct TreeNode { T val; int size; TreeNode<T> *left, *right, *parent; TreeNode(T val = 0, TreeNode<T> *parent = nullptr, TreeNode<T> *left = nullptr, TreeNode<T> *right = nullptr, int size = 1) : val(val), parent(parent), left(left), right(right), size(size) {} }; // 计算节点的大小 template <typename T> int getSize(TreeNode<T>* node) { return node ? node->size : 0; } // 更新节点的大小 template <typename T> void updateSize(TreeNode<T>* node) { if (node) { node->size = 1 + getSize(node->left) + getSize(node->right); } } // 向左旋转 template <typename T> void rotateLeft(TreeNode<T>* node) { TreeNode<T>* temp = node->right; if (temp) { node->right = temp->left; if (temp->left) { temp->left->parent = node; } temp->parent = node->parent; if (!node->parent) { node->parent = temp; } else if (node == node->parent->left) { node->parent->left = temp; } else { node->parent->right = temp; } temp->left = node; node->parent = temp; updateSize(node); updateSize(temp); } } // 向右旋转 template <typename T> void rotateRight(TreeNode<T>* node) { TreeNode<T>* temp = node->left; if (temp) { node->left = temp->right; if (temp->right) { temp->right->parent = node; } temp->parent = node->parent; if (!node->parent) { node->parent = temp; } else if (node == node->parent->right) { node->parent->right = temp; } else { node->parent->left = temp; } temp->right = node; node->parent = temp; updateSize(node); updateSize(temp); } } // 插入节点 template <typename T> TreeNode<T>* insert(TreeNode<T>* root, T val) { if (!root) { return new TreeNode<T>(val); } if (val < root->val) { root->left = insert(root->left, val); root->left->parent = root; } else { root->right = insert(root->right, val); root->right->parent = root; } updateSize(root); int lSize = getSize(root->left); int rSize = getSize(root->right); if (lSize > 2 * rSize || rSize > 2 * lSize) { int size = lSize + rSize + 1; TreeNode<T>* node = root; TreeNode<T>* parent = nullptr; while (node) { if (2 * getSize(node->left) < size && 2 * getSize(node->right) < size) { break; } parent = node; if (getSize(node->left) > getSize(node->right)) { node = node->left; } else { node = node->right; } } if (!parent) { root = node; } else if (node == parent->left) { parent->left = node; } else { parent->right = node; } node->parent = parent; while (node != root) { node = node->parent; updateSize(node); } } return root; } // 删除节点 template <typename T> TreeNode<T>* remove(TreeNode<T>* root, T val) { TreeNode<T>* node = root; while (node && node->val != val) { if (val < node->val) { node = node->left; } else { node = node->right; } } if (!node) { return root; } if (node->left && node->right) { TreeNode<T>* temp = node->right; while (temp->left) { temp = temp->left; } node->val = temp->val; node = temp; } TreeNode<T>* parent = node->parent; TreeNode<T>* child = node->left ? node->left : node->right; if (child) { child->parent = parent; } if (!parent) { root = child; } else if (node == parent->left) { parent->left = child; } else { parent->right = child; } while (parent) { updateSize(parent); int lSize = getSize(parent->left); int rSize = getSize(parent->right); if (lSize > 2 * rSize || rSize > 2 * lSize) { int size = lSize + rSize + 1; node = parent; parent = node->parent; if (!parent) { root = node; } else if (node == parent->left) { parent->left = node; } else { parent->right = node; } node->parent = parent; while (node != root) { node = node->parent; updateSize(node); } break; } node = parent; parent = node->parent; } delete node; return root; } // 查找节点 template <typename T> TreeNode<T>* find(TreeNode<T>* root, T val) { TreeNode<T>* node = root; while (node && node->val != val) { if (val < node->val) { node = node->left; } else { node = node->right; } } return node; } // 中序遍历 template <typename T> void inorder(TreeNode<T>* root) { if (root) { inorder(root->left); cout << root->val << " "; inorder(root->right); } } int main() { TreeNode<int>* root = nullptr; root = insert(root, 5); root = insert(root, 3); root = insert(root, 7); root = insert(root, 2); root = insert(root, 4); root = insert(root, 6); root = insert(root, 8); cout << "Inorder traversal of the constructed tree: "; inorder(root); cout << endl; root = remove(root, 3); root = remove(root, 6); cout << "Inorder traversal after deletion of 3 and 6: "; inorder(root); cout << endl; return 0; } ``` 在上面的代码中,我们使用了模板来支持不同类型的节点值。我们首先定义了一个 TreeNode 结构体,其中包含节点的值、大小、左子、右子和父节点等信息。然后我们实现了一些辅助函数,如 getSize、updateSize、rotateLeft 和 rotateRight 等函数,这些函数可以帮助我们更新节点的信息并且实现了左旋和右旋操作。 接下来,我们实现了 insert、remove 和 find 等操作。insert 操作用于插入节点,如果的不平衡程度超过了阈值,我们就需要进行重构操作。remove 操作用于删除节点,如果删除节点后的不平衡程度超过了阈值,我们也需要进行重构操作。find 操作用于查找节点,返回节点的指针。 最后,我们实现了一个简单的测试用例,插入一些节点并删除一些节点,最后输出中序遍历的结果。 希望这份代码可以帮助你更好地理解和实现替罪羊

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值