SizeBalanceTree

原创 已于 2022-06-29 00:08:57 修改 · 410 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#数据结构 #算法
于 2022-06-29 00:07:56 首次发布
本文介绍了SBT树，一种易于实现且保持平衡的数据结构，重点讲解了其节点定义、旋转操作（LL、RR、LR、RL违规处理）、插入和删除操作。通过实例展示了右旋和左旋的代码实现以及维护树性质的过程。

文章目录

SBT树的概念及其相关性质

众所周知二叉搜索树相比于其他数据结构的优势在于查找、插入的时间复杂度较低。为O(logN)。缺点是若待插入的序列是有序的，那么它会退化成单链表，这样查询时间将会退化为O(N)。

AVL树和红黑树对二叉搜索树进行了升级，增加平衡和旋转操作。但是红黑树实现起来比较复杂，AVL过于平衡导致旋转的开销过大。

SBT树是一个相对来讲容易实现，并且平衡性又不错的树。

SBT树相关性质：
任何一个叔叔节点为根的子树节点的个数不能少于侄子节点的个数，比如：
在这里插入图片描述

节点的定义

struct SBTNode
{
	SBTNode(const pair<K, V>kv = pair<K, V>())
		:_kv(kv)
		,_left(nullptr)
		,_right(nullptr)
		,_size(1)
	{}
	pair<K, V>_kv;
	SBTNode<K, V>* _left;
	SBTNode<K, V>* _right;
	int _size;//节点的个数
};

旋转操作

  1. LL型违规
    LL型违规顾名思义就是根节点左孩子的左孩子的size比根节点右孩子大。

在这里插入图片描述

此时我们对根节点进行右旋，让D节点来做叔叔节点，C节点作为D的侄子节点。
在这里插入图片描述

但是进行右旋之后，我们会发现B和A的孩子发生了变化，此时需要递归检查它们是否符合BST的性质。

  1. RR型违规
    根节点右孩子的右孩子的size比根节点的左孩子大。

在这里插入图片描述

同样的我们也需要对C和A进行递归检查操作。

  1. LR型违规
    LR型是指根节点左孩子的右孩子节点的个数大于根节点右孩子的个数。
    在这里插入图片描述

经过旋转之后ABE这三个节点的左右孩子发生了变化，因此需要对其进行递归检查。

  1. RL型违规
    RL型是指根节点右孩子的左孩子节点的个数大于根节点左孩子的个数。
    在这里插入图片描述
    经过旋转之后ACF这三个节点的左右孩子发生了变化，因此需要对其进行递归检查。

代码操作：

	//右旋
	Node* rightRotate(Node* cur) 
	{
		//找到新的根节点
		Node* leftNode = cur->_left;
		cur->_left = leftNode->_right;
		leftNode->_right = cur;
		//根节点的size更新
		leftNode->_size = cur->_size;
		//cur的size更新
		cur->_size = (cur->_left ? cur->_left->_size : 0) + (cur->_right ? cur->_right->_size : 0) + 1;

		return leftNode;
	}
	//左旋
	Node* leftRotate(Node* cur) 
	{
		Node* rightNode = cur->_right;
		cur->_right = rightNode->_left;
		rightNode->_left = cur;
		rightNode->_size = cur->_size;
		cur->_size = (cur->_left ? cur->_left->_size : 0) + (cur->_right ? cur->_right->_size : 0) + 1;
		return rightNode;
	}
	//调整节点的操作
	Node* maintain(Node* cur)
	{
		if (cur == nullptr)
		{
			return nullptr;
		}
		//将节点的个数拿出来
		//左孩子
		int leftSize = cur->_left != nullptr ? cur->_left->_size : 0;
		//左孩子的左孩子
		int leftLeftSize = cur->_left && cur->_left->_left ? cur->_left->_left->_size : 0;
		//左孩子的右孩子
		int leftRightSize = cur->_left && cur->_left->_right ? cur->_left->_right->_size : 0;
		//右孩子
		int rightSize = cur->_right ? cur->_right->_size : 0;
		//右孩子的左孩子
		int rightLeftSize = cur->_right && cur->_right->_left ? cur->_right->_left->_size : 0;
		//右孩子的右孩子
		int rightRightSize = cur->_right && cur->_right->_right ? cur->_right->_right->_size : 0;
		//LL型违规
		if (leftLeftSize > rightSize)
		{
			//右旋
			cur = rightRotate(cur);
			//递归检查
			cur->_right = maintain(cur->_right);
			cur = maintain(cur);
		}
		//LR型
		else if (leftRightSize > rightSize) 
		{
			//左右双旋
			cur->_left = leftRotate(cur->_left);
			cur = rightRotate(cur);
			//递归检查
			cur->_left = maintain(cur->_left);
			cur->_right = maintain(cur->_right);
			cur = maintain(cur);
		}
		//RR型
		else if (rightRightSize > leftSize) 
		{
			cur = leftRotate(cur);
			cur->_left = maintain(cur->_left);
			cur = maintain(cur);
		}
		//RL型
		else if (rightLeftSize > leftSize) 
		{
			cur->_right = rightRotate(cur->_right);
			cur = leftRotate(cur);
			cur->_left = maintain(cur->_left);
			cur->_right = maintain(cur->_right);
			cur = maintain(cur);
		}
		return cur;//返回调整后的头部
	}

插入和删除操作

插入与删除操作与AVL树相同，不过插入时要对路径上的节点中的size+1，删除时-1，并且在返回前对他们进行调整。

//新增节点的操作，在找寻插入位置时要对路径上节点的size++
	//并且找到后，对整棵树进行调整，因为新增节点会破坏BST的性质
	Node* add(Node*& cur, const pair<K, V>& kv) 
	{
		if (cur == nullptr) 
		{
			return new Node(kv);
		}
		else 
		{
			//由于要递归向下找插入的位置
			//因此对沿途节点的size自增
			cur->_size++;
			if (cur->_kv.first > kv.first) 
			{
				cur->_left = add(cur->_left, kv);//去左边插入
			}
			else 
			{
				cur->_right = add(cur->_right, kv);//去右边插入
			}
		}
		//返回前进行调整
		return maintain(cur);
	}
	//插入节点
	bool insert(const pair<K, V>& kv) 
	{
		//先找一下这个节点，如果存在就直接返回
		Node* lastNode = findLastIndex(kv.first);
		//已经存在
		if (lastNode && lastNode->_kv.first == kv.first) 
		{
			return false;
		}
		_root = add(_root, kv);
		return true;
	}

	//删除节点
	Node* deleteNode(Node*& cur, const K& key)
	{
		//删除路径上节点的size减少
		cur->_size--;
		if (cur->_kv.first > key) 
		{
			cur->_left = deleteNode(cur->_left, key);
		}
		else if (cur->_kv.first < key) 
		{
			cur->_right = deleteNode(cur->_right, key);//左边删并将新的头部返回
		}
		else 
		{
			//左为空并且右为空，直接删
			if (!cur->_left && !cur->_right) 
			{
				delete cur;
				cur = nullptr;
			}
			//左为空但右不为空,拿右节点代替
			else if (!cur->_left && cur->_right) 
			{
				Node* subR = cur->_right;
				delete cur;
				cur = subR;
			}
			//左不为空右为空，拿左节点代替
			else if (cur->_left && !cur->_right) 
			{
				Node* subL = cur->_left;
				delete cur;
				cur = subL;
			}
			//左右都不为空
			else 
			{
				Node* pre = nullptr;
				//找右子树的最左节点，并且路径上的值--
				Node* des = cur->_right;
				des->_size--;
				while (des->_left) 
				{
					pre = des;
					des = des->_left;
					des->_size--;
				}
				//替换法删除
				//将des换到头结点，des的位置用右子树替代
				if (pre) 
				{
					pre->_left = des->_right;
					des->_right = cur->_right;
				}
				des->_left = cur->_left;
				//更新size
				des->_size = des->_left->_size + (des->_right ? des->_right->_size : 0) + 1;

				delete cur;
				cur = des;
			}
		}
		//在返回前进行调整
		cur = maintain(cur);

		return cur;//返回新头部
	}

总代码

#pragma once 
#include<math.h>
#include<iostream>
#include<vector>
using namespace std;
template<class K, class V>
struct SBTNode
{
	SBTNode(const pair<K, V>kv = pair<K, V>())
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _size(1)
	{}
	pair<K, V>_kv;
	SBTNode<K, V>* _left;
	SBTNode<K, V>* _right;
	int _size;//节点的个数
};
template<class K, class V>
class SizeBalancedTreeMap {
	typedef SBTNode<K, V> Node;
public:
	//右旋
	Node* rightRotate(Node* cur) 
	{
		//找到新的根节点
		Node* leftNode = cur->_left;
		cur->_left = leftNode->_right;
		leftNode->_right = cur;
		//根节点的size更新
		leftNode->_size = cur->_size;
		//cur的size更新
		cur->_size = (cur->_left ? cur->_left->_size : 0) + (cur->_right ? cur->_right->_size : 0) + 1;

		return leftNode;
	}
	//左旋
	Node* leftRotate(Node* cur) 
	{
		Node* rightNode = cur->_right;
		cur->_right = rightNode->_left;
		rightNode->_left = cur;
		rightNode->_size = cur->_size;
		cur->_size = (cur->_left ? cur->_left->_size : 0) + (cur->_right ? cur->_right->_size : 0) + 1;
		return rightNode;
	}
	//调整节点的操作
	Node* maintain(Node* cur)
	{
		if (cur == nullptr)
		{
			return nullptr;
		}
		//将节点的个数拿出来
		//左孩子
		int leftSize = cur->_left != nullptr ? cur->_left->_size : 0;
		//左孩子的左孩子
		int leftLeftSize = cur->_left && cur->_left->_left ? cur->_left->_left->_size : 0;
		//左孩子的右孩子
		int leftRightSize = cur->_left && cur->_left->_right ? cur->_left->_right->_size : 0;
		//右孩子
		int rightSize = cur->_right ? cur->_right->_size : 0;
		//右孩子的左孩子
		int rightLeftSize = cur->_right && cur->_right->_left ? cur->_right->_left->_size : 0;
		//右孩子的右孩子
		int rightRightSize = cur->_right && cur->_right->_right ? cur->_right->_right->_size : 0;
		//LL型违规
		if (leftLeftSize > rightSize)
		{
			//右旋
			cur = rightRotate(cur);
			//递归检查
			cur->_right = maintain(cur->_right);
			cur = maintain(cur);
		}
		//LR型
		else if (leftRightSize > rightSize) 
		{
			//左右双旋
			cur->_left = leftRotate(cur->_left);
			cur = rightRotate(cur);
			//递归检查
			cur->_left = maintain(cur->_left);
			cur->_right = maintain(cur->_right);
			cur = maintain(cur);
		}
		//RR型
		else if (rightRightSize > leftSize) 
		{
			cur = leftRotate(cur);
			cur->_left = maintain(cur->_left);
			cur = maintain(cur);
		}
		//RL型
		else if (rightLeftSize > leftSize) 
		{
			cur->_right = rightRotate(cur->_right);
			cur = leftRotate(cur);
			cur->_left = maintain(cur->_left);
			cur->_right = maintain(cur->_right);
			cur = maintain(cur);
		}
		return cur;//返回调整后的头部
	}

	//新增节点的操作，在找寻插入位置时要对路径上节点的size++
	//并且找到后，对整棵树进行调整，因为新增节点会破坏BST的性质
	Node* add(Node*& cur, const pair<K, V>& kv) 
	{
		if (cur == nullptr) 
		{
			return new Node(kv);
		}
		else 
		{
			//由于要递归向下找插入的位置
			//因此对沿途节点的size自增
			cur->_size++;
			if (cur->_kv.first > kv.first) 
			{
				cur->_left = add(cur->_left, kv);//去左边插入
			}
			else 
			{
				cur->_right = add(cur->_right, kv);//去右边插入
			}
		}
		//返回前进行调整
		return maintain(cur);
	}
	//插入节点
	bool insert(const pair<K, V>& kv) 
	{
		//先找一下这个节点，如果存在就直接返回
		Node* lastNode = findLastIndex(kv.first);
		//已经存在
		if (lastNode && lastNode->_kv.first == kv.first) 
		{
			return false;
		}
		_root = add(_root, kv);
		return true;
	}

	//删除节点
	Node* deleteNode(Node*& cur, const K& key)
	{
		//删除路径上节点的size减少
		cur->_size--;
		if (cur->_kv.first > key) 
		{
			cur->_left = deleteNode(cur->_left, key);
		}
		else if (cur->_kv.first < key) 
		{
			cur->_right = deleteNode(cur->_right, key);//左边删并将新的头部返回
		}
		else 
		{
			//左为空并且右为空，直接删
			if (!cur->_left && !cur->_right) 
			{
				delete cur;
				cur = nullptr;
			}
			//左为空但右不为空,拿右节点代替
			else if (!cur->_left && cur->_right) 
			{
				Node* subR = cur->_right;
				delete cur;
				cur = subR;
			}
			//左不为空右为空，拿左节点代替
			else if (cur->_left && !cur->_right) 
			{
				Node* subL = cur->_left;
				delete cur;
				cur = subL;
			}
			//左右都不为空
			else 
			{
				Node* pre = nullptr;
				//找右子树的最左节点，并且路径上的值--
				Node* des = cur->_right;
				des->_size--;
				while (des->_left) 
				{
					pre = des;
					des = des->_left;
					des->_size--;
				}
				//替换法删除
				//将des换到头结点，des的位置用右子树替代
				if (pre) 
				{
					pre->_left = des->_right;
					des->_right = cur->_right;
				}
				des->_left = cur->_left;
				//更新size
				des->_size = des->_left->_size + (des->_right ? des->_right->_size : 0) + 1;

				delete cur;
				cur = des;
			}
		}
		//在返回前进行调整
		cur = maintain(cur);

		return cur;//返回新头部
	}

	//删除key节点
	void erase(const K& key) 
	{
		Node* lastNode = findLastIndex(key);
		if (lastNode)
			_root = deleteNode(_root, key);
		else 
		{
			return;
		}
	}
	//在搜索树中找key节点
	Node* findLastIndex(const K& key)
	{
		Node* pre = _root;
		Node* cur = _root;
		while (cur != nullptr) 
		{
			pre = cur;
			if (cur->_kv.first == key) 
			{
				break;
			}
			else if (cur->_kv.first > key) 
			{
				cur = cur->_left;
			}
			else 
			{
				cur = cur->_right;
			}
		}
		return pre;
	}
	//找到比key大的最小的节点
	Node* findLastNoSmallIndex(const K& key) 
	{
		Node* ans = nullptr;
		Node* cur = _root;
		while (cur != nullptr) 
		{
			if (cur->_kv.first == key) 
			{
				ans = cur;
				break;
			}
			else if (cur->_kv.first > key) 
			{
				ans = cur;
				cur = cur->_left;
			}
			else 
			{
				cur = cur->_right;
			}
		}
		return ans;
	}
	//找到比key小的最大的节点
	Node* findLastNoBigIndex(const K& key)
	{
		Node* ans = nullptr;
		Node* cur = _root;
		while (cur != nullptr) 
		{
			if (cur->_kv.first == key) 
			{
				ans = cur;
				break;
			}
			else if (cur->_kv.first > key) 
			{
				cur = cur->_left;
			}
			else 
			{
				ans = cur;
				cur = cur->_right;
			}
		}
		return ans;
	}
	//判断key是否在树中
	bool  containsKey(const K& key)
	{

		Node* lastNode = findLastIndex(key);
		return lastNode && lastNode->_kv.first == key ? true : false;
	}
	//中序遍历
	void _Inorder(Node*& root) 
	{
		if (!root)return;
		_Inorder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_Inorder(root->_right);
	}
	void Inorder() 
	{
		_Inorder(_root);
	}

private:
	Node* _root = nullptr;
};

在这里插入图片描述

节点大小平衡树(（Size Balanced Tree, c++和python源码）
02-26
我自己写的SBTree的实现 参考了http://www.nocow.cn/index.php/Size_Balanced_Tree的算法 声明：此源码可以用于商业用途，但请注明来源于random
SizeBalanceTree详解（含代码实现）
qq_56999918的博客
02-03 2020
+1.SBT树的概念及其相关性质 Size Balanced Tree(SBT)是一种平衡二叉查找树。它的论文由中国广东中山记念中学的陈启峰于2006年末完成，php 并在Winter Camp 2007中发表。因为SBT的拼写很容易找到中文谐音， 它常被中国的Oler们戏称为 “傻X树”、html “Super BT”等。但它的性能并不SB，编写起来也并不BT。偏偏相反，SBT易于实现，且据陈启峰论文中所言 ，node “这是目前为止速度最快的高级二叉搜索树”。它能在O(logn)的时间..
【数据结构与算法】Size Balanced Tree（SBT）平衡二叉树
小哲的博客
11-02 1886
尺寸平衡树（SBT）平衡二叉树 原文链接大小平衡树（SBT）平衡二叉树 定义数据结构 struct SBT { int key,left,right,size; } tree[N]; 关键：存储值，左，右：左右子树，大小：保持平衡最终要的数据，表示子树的大小 SBT树的性质 定义一个节点X，同时满足下面两个条件 (a)、x.left.size &gt;= max(x.r...
竞赛最好用的平衡树-Size Balanced Tree（SBT）【建议收藏】
x0919的博客
10-24 4043
大家好。 前段时间我更新过AVL、红黑树以及搜索二叉树的简单讲解。今天我们还是围绕着平衡树的话题，来讲解一个很牛逼的平衡树结构。这种结构是我国的一位大牛：陈启峰。在2006年，他还在读高中阶段，所发明的一种平衡树结构，叫Size Balanced Tree（SBT），根据节点的个数，来调整平衡性。一直到今天，这种平衡树结构，在算法竞赛领域是非常常用的，虽然SBT的时间复杂度跟AVL、红黑树这些平衡树一样，但是SBT是比较好写，比较好改的。所以在算法竞赛时，是最常用的一种算法。陈启峰SBT论文（译） 本期文章
size balanced tree (平衡二叉树) ----- 傻X树----陈启峰论文
杨鑫newlife的专栏
11-05 5318
Size Balanced Tree(SBT)是一种平衡二叉查找树。它的论文由中国广东中山纪念中学的陈启峰于2006年底完成，并在Winter Camp 2007中发表。由于SBT的拼写很容易找到中文谐音，它常被中国的OIer们戏称为“傻X树”、“Super BT”等。但它的性能并不SB，编写起来也并不BT。恰恰相反，SBT易于实现，且据陈启峰论文中所言，“这是目前为止速度最快的高级二叉搜
有序表之SB树（Size Balanced Tree）
明朗晨光的专栏
02-15 1655
1、SB树的失衡类型及失衡的调整方式 2、SB树的代码实现
有序表之SizeBalanceTree
Harrison的学习博客
04-04 813
SB树的平衡标准 任何以叔叔结点的为头的子树的结点个数不小于任何一个以自己侄子为头结点的子树的结点个数。
37.1：sizeBalanceTree
深入探索技术领域，持续学习成长，追求实践与进步，共同构建技术未来
08-24 270
37.1：sizeBalanceTree
有序表3：Size-BalanceTree
个人专长：数据结构和算法、大数据、数据库、主流框架
06-01 279
有序表第三篇文章：SB树，全名Size-BalanceTree
SizeBalancedTrees
Darkside的博客
10-14 317
前言 BST一直都是卡常的领域，为了不被卡常，我们需要一个更平衡的BST，SizeBalanceTree就是不错的选择。 旋转 众所周知，平衡树分为两类，非旋平衡树和旋转平衡树， SizeBalanceTree是依靠旋转来保持平衡的。 左旋 左旋的意思就是把当前节点移到左边去，同时保持树的中序遍历不变，右旋也是同理(代码与左旋对称)，注意保持树的中序遍历不变是非常重要的，它决定了树的搜索性质是否变化； 右旋 代码 inline void Rotate(int &now,bool flag) {
size balance tree 的基本操作
To be excellent！
05-07 1371
（参考2007国家集训队论文 size balance tree -陈启峰） 此处附上SBT中文版讲解传送门：http://wenku.baidu.com/view/364afa42a8956bec0975e3b1.html
Size Balance Tree
GadyPu的专栏
04-07 708
Size Balance Tree
Size Balanced Tree（SBT）平衡二叉树
热门推荐
fmt.Println(
10-31 1万+
定义数据结构 struct SBT { int key,left,right,size; } tree[N];key:存储值，left,right：左右子树，size：保持平衡最终要的数据，表示子树的大小 SBT树的性质 定义一个节点x，同时满足下面两个条件 (a)、x.left.size >= max(x.right.right.size, x.right.left.si
Size Balanced Tree
Make Progress Everyday!
08-02 1484
 今天上网搜索关于红黑树的资料时，发现一种新的平衡二叉树（SBT），据说各方面性能很好，先摘录在此，以后再细看。 Size Balanced Tree(SBT)是一种平衡二叉查找树。它的论文由中国广东中山纪念中学的陈启峰于2006年底完成，并在Winter Camp 2007中发表。由于SBT的拼写很容易找到中文谐音，它常被中国的OIer们戏称为“傻X树”、“Super BT”等。但它
SB tree （Size Balanced Tree）
SprintfWater的专栏
12-18 4531
转载：http://www.clarkok.com/blog/?p=347#more-347 采取网友建议，写一下SB Tree。 ============================================================================ 所谓SB，并不是傻X，而是Size Balanced的意思的。本人也比较建议使用，因为写起来比较简单。这
Size Balance Tree和Treap的ADT接口和实现
tianyu的专栏 - Linux site:blog.csdn.net/wishfly
12-17 1252
 1M个整数插入删除，不优化的情况下， SBT费时5.2秒，Treap才2.1秒，说SBT比Treap快，怎么不觉得了，不明白文件：include/Item.h[Copy to clipboard] [ - ]CODE:/*-----------------------------------------------------------        Item.h  
Java基础 - 节点自平衡树（Size Balanced Tree，简称SBT）
ApatheCrazyFan的博客
12-09 1568
package com.yc.tree; import java.util.ArrayDeque; import java.util.ArrayList; import java.util.Deque; import java.util.List; public class SizeBalancedTree >{ public class Node{ //data域：存放数据项 T
Size Balanced Tree(节点大小平衡树)
weixin_30415801的博客
01-27 334
定义 SBT也是一种自平衡二叉查找树,它的平衡原理是每棵树的大小不小于其兄弟树的子树的大小 即size(x->l)$\ge$size(x->r->l),size(x->r->r),右边同理size(x->r)$\ge$size(x->l->l),size(x->l->r) 具体操作 　　旋转 　　　　旋转几乎是所有平衡树所共有的...
Python 优雅解析 Excel：从原生行列到强类型对象的三层数据结构演进
最新发布
asdzx67的博客
06-15 337
对于数据结构固定、业务逻辑复杂的 Excel 场景，字典结构的弱类型特性会带来类型混乱、无代码提示、无法封装业务逻辑等问题。定义业务实体类，将每行 Excel 数据映射为实体对象，实现强类型约束、自动代码补全、自定义数据校验和业务方法封装。从「二维列表数字索引」到「字典语义取值」，再到「自定义对象强类型封装」，三层数据结构的迭代，本质是代码从「机器思维」向「业务思维」的升级。简单场景无需过度设计，通用场景优先字典列表，工程化复杂场景首选自定义实体对象。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

今天也要写bug、

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值