Set Balance Tree（SB树）——有序表2

已于 2022-10-29 17:06:08 修改
阅读量437 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： java 算法 数据结构
于 2022-10-27 11:18:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z1171127310/article/details/127548389
版权

目录

一、基本概念

1.达到平衡时要求

2.不同类型的判断标准

二、代码实现

三、总结

一、基本概念

1.达到平衡时要求

  • 每棵子树的大小，不小于其兄弟的子树大小
  • 既每棵叔叔树的大小，不小于其任何侄子树的大小

2.不同类型的判断标准

假设当前节点为X。

        LL:        X.left.left > X.right

        LR:        X.left.right > X.right

        RR:        X.right.right> X.left

        RL:         X.right.left> X.left

二、代码实现

//左神上课代码
public class SizeBalancedTreeMapClass {

	public static class SBTNode<K extends Comparable<K>, V> {
		public K key;
		public V value;
		public SBTNode<K, V> l;
		public SBTNode<K, V> r;
		public int size; // 不同的key的数量

		public SBTNode(K key, V value) {
			this.key = key;
			this.value = value;
			size = 1;
		}
	}

	public static class SizeBalancedTreeMap<K extends Comparable<K>, V> {
		private SBTNode<K, V> root;

		private SBTNode<K, V> rightRotate(SBTNode<K, V> cur) {
			SBTNode<K, V> leftNode = cur.l;
			cur.l = leftNode.r;
			leftNode.r = cur;
			leftNode.size = cur.size;
			cur.size = (cur.l != null ? cur.l.size : 0) + 
					(cur.r != null ? cur.r.size : 0) + 1;
			return leftNode;
		}

		private SBTNode<K, V> leftRotate(SBTNode<K, V> cur) {
			SBTNode<K, V> rightNode = cur.r;
			cur.r = rightNode.l;
			rightNode.l = cur;
			rightNode.size = cur.size;
			cur.size = (cur.l != null ? cur.l.size : 0) + 
					(cur.r != null ? cur.r.size : 0) + 1;
			return rightNode;
		}

		private SBTNode<K, V> maintain(SBTNode<K, V> cur) {
			if (cur == null) {
				return null;
			}
			int leftSize = cur.l != null ? cur.l.size : 0;
			int leftLeftSize = cur.l != null && 
					cur.l.l != null ? cur.l.l.size : 0;
			int leftRightSize = cur.l != null && 
					cur.l.r != null ? cur.l.r.size : 0;
			int rightSize = cur.r != null ? cur.r.size : 0;
			int rightLeftSize = cur.r != null && 
					cur.r.l != null ? cur.r.l.size : 0;
			int rightRightSize = cur.r != null && 
					cur.r.r != null ? cur.r.r.size : 0;
			if (leftLeftSize > rightSize) {
				cur = rightRotate(cur);
				cur.r = maintain(cur.r);
				cur = maintain(cur);
			} else if (leftRightSize > rightSize) {
				cur.l = leftRotate(cur.l);
				cur = rightRotate(cur);
				cur.l = maintain(cur.l);
				cur.r = maintain(cur.r);
				cur = maintain(cur);
			} else if (rightRightSize > leftSize) {
				cur = leftRotate(cur);
				cur.l = maintain(cur.l);
				cur = maintain(cur);
			} else if (rightLeftSize > leftSize) {
				cur.r = rightRotate(cur.r);
				cur = leftRotate(cur);
				cur.l = maintain(cur.l);
				cur.r = maintain(cur.r);
				cur = maintain(cur);
			}
			return cur;
		}

		private SBTNode<K, V> findLastIndex(K key) {
			SBTNode<K, V> pre = root;
			SBTNode<K, V> cur = root;
			while (cur != null) {
				pre = cur;
				if (key.compareTo(cur.key) == 0) {
					break;
				} else if (key.compareTo(cur.key) < 0) {
					cur = cur.l;
				} else {
					cur = cur.r;
				}
			}
			return pre;
		}

		private SBTNode<K, V> findLastNoSmallIndex(K key) {
			SBTNode<K, V> ans = null;
			SBTNode<K, V> cur = root;
			while (cur != null) {
				if (key.compareTo(cur.key) == 0) {
					ans = cur;
					break;
				} else if (key.compareTo(cur.key) < 0) {
					ans = cur;
					cur = cur.l;
				} else {
					cur = cur.r;
				}
			}
			return ans;
		}

		private SBTNode<K, V> findLastNoBigIndex(K key) {
			SBTNode<K, V> ans = null;
			SBTNode<K, V> cur = root;
			while (cur != null) {
				if (key.compareTo(cur.key) == 0) {
					ans = cur;
					break;
				} else if (key.compareTo(cur.key) < 0) {
					cur = cur.l;
				} else {
					ans = cur;
					cur = cur.r;
				}
			}
			return ans;
		}

		// 现在，以cur为头的树上，新增，加(key, value)这样的记录
		// 加完之后，会对cur做检查，该调整调整
		// 返回，调整完之后，整棵树的新头部
		private SBTNode<K, V> add(SBTNode<K, V> cur, K key, V value) {
			if (cur == null) {
				return new SBTNode<K, V>(key, value);
			} else {
				cur.size++;
				if (key.compareTo(cur.key) < 0) {
					cur.l = add(cur.l, key, value);
				} else {
					cur.r = add(cur.r, key, value);
				}
				return maintain(cur);
			}
		}

		// 在cur这棵树上，删掉key所代表的节点
		// 返回cur这棵树的新头部
		private SBTNode<K, V> delete(SBTNode<K, V> cur, K key) {
			cur.size--;
			if (key.compareTo(cur.key) > 0) {
				cur.r = delete(cur.r, key);
			} else if (key.compareTo(cur.key) < 0) {
				cur.l = delete(cur.l, key);
			} else { // 当前要删掉cur
				if (cur.l == null && cur.r == null) {
					// free cur memory -> C++
					cur = null;
				} else if (cur.l == null && cur.r != null) {
					// free cur memory -> C++
					cur = cur.r;
				} else if (cur.l != null && cur.r == null) {
					// free cur memory -> C++
					cur = cur.l;
				} else { // 有左有右
					SBTNode<K, V> pre = null;
					SBTNode<K, V> des = cur.r;
					des.size--;
					while (des.l != null) {
						pre = des;
						des = des.l;
						des.size--;
					}
					if (pre != null) {
						pre.l = des.r;
						des.r = cur.r;
					}
					des.l = cur.l;
					des.size = des.l.size + (des.r == null ? 
							0 : des.r.size) + 1;
					// free cur memory -> C++
					cur = des;
				}
			}
			// cur = maintain(cur);
			return cur;
		}

		private SBTNode<K, V> getIndex(SBTNode<K, V> cur, int kth) {
			if (kth == (cur.l != null ? cur.l.size : 0) + 1) {
				return cur;
			} else if (kth <= (cur.l != null ? cur.l.size : 0)) {
				return getIndex(cur.l, kth);
			} else {
				return getIndex(cur.r, 
						kth - (cur.l != null ? cur.l.size : 0) - 1);
			}
		}

		public int size() {
			return root == null ? 0 : root.size;
		}

		public boolean containsKey(K key) {
			if (key == null) {
				throw new RuntimeException("invalid parameter.");
			}
			SBTNode<K, V> lastNode = findLastIndex(key);
			return lastNode != null && 
					key.compareTo(lastNode.key) == 0 ? true : false;
		}

		// （key，value） put -> 有序表 新增、改value
		public void put(K key, V value) {
			if (key == null) {
				throw new RuntimeException("invalid parameter.");
			}
			SBTNode<K, V> lastNode = findLastIndex(key);
			if (lastNode != null && key.compareTo(lastNode.key) == 0) {
				lastNode.value = value;
			} else {
				root = add(root, key, value);
			}
		}

		public void remove(K key) {
			if (key == null) {
				throw new RuntimeException("invalid parameter.");
			}
			if (containsKey(key)) {
				root = delete(root, key);
			}
		}

		public K getIndexKey(int index) {
			if (index < 0 || index >= this.size()) {
				throw new RuntimeException("invalid parameter.");
			}
			return getIndex(root, index + 1).key;
		}

		public V getIndexValue(int index) {
			if (index < 0 || index >= this.size()) {
				throw new RuntimeException("invalid parameter.");
			}
			return getIndex(root, index + 1).value;
		}

		public V get(K key) {
			if (key == null) {
				throw new RuntimeException("invalid parameter.");
			}
			SBTNode<K, V> lastNode = findLastIndex(key);
			if (lastNode != null && key.compareTo(lastNode.key) == 0) {
				return lastNode.value;
			} else {
				return null;
			}
		}

		public K firstKey() {
			if (root == null) {
				return null;
			}
			SBTNode<K, V> cur = root;
			while (cur.l != null) {
				cur = cur.l;
			}
			return cur.key;
		}

		public K lastKey() {
			if (root == null) {
				return null;
			}
			SBTNode<K, V> cur = root;
			while (cur.r != null) {
				cur = cur.r;
			}
			return cur.key;
		}

		public K floorKey(K key) {
			if (key == null) {
				throw new RuntimeException("invalid parameter.");
			}
			SBTNode<K, V> lastNoBigNode = findLastNoBigIndex(key);
			return lastNoBigNode == null ? null : lastNoBigNode.key;
		}

		public K ceilingKey(K key) {
			if (key == null) {
				throw new RuntimeException("invalid parameter.");
			}
			SBTNode<K, V> lastNoSmallNode = findLastNoSmallIndex(key);
			return lastNoSmallNode == null ? null : lastNoSmallNode.key;
		}

	}

	// for test
	public static void printAll(SBTNode<String, Integer> head) {
		System.out.println("Binary Tree:");
		printInOrder(head, 0, "H", 17);
		System.out.println();
	}

	// for test
	public static void printInOrder(SBTNode<String, Integer> head, 
			int height, String to, int len) {
		if (head == null) {
			return;
		}
		printInOrder(head.r, height + 1, "v", len);
		String val = to + "(" + head.key + "," + head.value + ")" + to;
		int lenM = val.length();
		int lenL = (len - lenM) / 2;
		int lenR = len - lenM - lenL;
		val = getSpace(lenL) + val + getSpace(lenR);
		System.out.println(getSpace(height * len) + val);
		printInOrder(head.l, height + 1, "^", len);
	}

	// for test
	public static String getSpace(int num) {
		String space = " ";
		StringBuffer buf = new StringBuffer("");
		for (int i = 0; i < num; i++) {
			buf.append(space);
		}
		return buf.toString();
	}

	public static void main(String[] args) {
		SizeBalancedTreeMap<String, Integer> sbt = 
				new SizeBalancedTreeMap<String, Integer>();
		sbt.put("d", 4);
		sbt.put("c", 3);
		sbt.put("a", 1);
		sbt.put("b", 2);
		// sbt.put("e", 5);
		sbt.put("g", 7);
		sbt.put("f", 6);
		sbt.put("h", 8);
		sbt.put("i", 9);
		sbt.put("a", 111);
		System.out.println(sbt.get("a"));
		sbt.put("a", 1);
		System.out.println(sbt.get("a"));
		for (int i = 0; i < sbt.size(); i++) {
			System.out.println(sbt.getIndexKey(i) + " , " + 
		sbt.getIndexValue(i));
		}
		printAll(sbt.root);
		System.out.println(sbt.firstKey());
		System.out.println(sbt.lastKey());
		System.out.println(sbt.floorKey("g"));
		System.out.println(sbt.ceilingKey("g"));
		System.out.println(sbt.floorKey("e"));
		System.out.println(sbt.ceilingKey("e"));
		System.out.println(sbt.floorKey(""));
		System.out.println(sbt.ceilingKey(""));
		System.out.println(sbt.floorKey("j"));
		System.out.println(sbt.ceilingKey("j"));
		sbt.remove("d");
		printAll(sbt.root);
		sbt.remove("f");
		printAll(sbt.root);

	}

}

三、总结

        搜索二叉树、AVL树、SB树、红黑树

朂後 哋箹萣
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Stern-Brocot Tree(SB树)
Freopen的博客
01-13 691
参考资料1 参考资料2 例题：HDU 6209 求K23K^{\frac 23}K32​的最接近且分母<=1e5<=1e5<=1e5的分数。 注意这里求的是最接近，所以参考资料1的方法需要做出一些调整。 应该是[a,b,c,d]−>[a+kc,b+kd,c,d][a,b,c,d]->[a+kc,b+kd,c,d][a,b,c,d]−>[a+kc,b+kd,c,d...
Java基于二分搜索树、链表的实现的集合Set复杂度分析实例详解
08-19
在Java编程语言中，集合框架提供了多种数据结构，如Set接口的实现，其中包括基于二分搜索树（Binary Search Tree, BST）和链表的数据结构。本篇将详细讲解这两种实现方式的集合Set在操作上的时间复杂度分析。 首先...
SB树
bllsll
09-21 1631
1.farey 序列（法里序列） POJ - 2478 题意： F2 = {1/2} F3 = {1/3, 1/2, 2/3} F4 = {1/4, 1/3, 1/2, 2/3, 3/4} F5 = {1/5, 1/4, 1/3, 2/5, 1/2, 3/5, 2/3, 3/4, 4/5} 问Fn有多少项 解法，可以看出来，Fn的解就是从2到n的欧拉函数的和 打个表求欧拉函数就行了，然后可
有序表之SB树（Size Balanced Tree）
明朗晨光的专栏
02-15 1040
1、SB树的失衡类型及失衡的调整方式 2、SB树的代码实现
Size Blanced Tree(SB树)
xiaolu567的博客
06-19 399
任何一个叔叔节点拥有的节点数,不少于他自己的任何一个侄子节点 叔叔节点:对于左树的左右孩子节点,叔叔节点为右树节点,同理对于右树的左右孩子节点,叔叔节点为左树节点,即叔叔节点为父亲节点的兄弟节点在调整过程中,哪个节点更改了孩子就要对该节点进行调整与AVL树第一步相同,先对顶部节点右旋 在右旋过程中,a和b节点的孩子会发生改变,因此递归调用maintain(a)和maintain(b) 如图,在左旋过程中,a和c的孩子节点发生改变,因此递归调用maintain(a)和maintain© 在调整过程中,e,b
Size Balanced Tree(SBT树)整理
weixin_30414245的博客
11-29 556
不想用treap和Splay，那就用SB树把，哈哈，其实它一点也SB，厉害着呢。 先膜拜一下作者陈启峰。Orz 以下内容由我搜集整理得来。 一、BST及其局限性 二叉查找树（Binary Search Tree），也称有序二叉树（ordered binary tree）,排序二叉树（sorted binary tree），是指一棵空树或者具有下列性质的二叉树： 1.若任意...
TreeTraversal:MySQL树遍历的实际例子
05-17
在"TreeTraversal-master"这个压缩包中，很可能包含了一个示例项目，演示了如何在MySQL中实现嵌套集模型和树遍历。通过阅读源代码和运行示例，你可以更深入地理解这些概念，并将其应用到自己的项目中。记得根据实际...
寒假培训——set
01-07
set中数据是有序的，可以直接搭配lower_bound或者upper_bound使用 相似的数集简单版-SET setaaa[52],a[i]中的每一个元素都是setaaa; num2是两个数集中相同的元素个数； NOIP 题海战-SET-1 说说易错的地方： 可能...
Java 从Set里面取出有序的记录详解及实例
08-30
TreeSet内部基于红黑树（Red-Black Tree）数据结构，因此它能保证元素的排序性。当向TreeSet添加元素时，会根据元素的自然排序（即元素实现了Comparable接口）或者自定义排序（通过传入Comparator对象）来决定元素的...
rbt.rar_rbt_red black tree_动态演示_红黑树
09-14
红黑树（Red-Black Tree）是一种自平衡二叉查找树，由计算机科学家Rudolf Bayer于1972年提出。它在保持了二叉查找树基本特性的同时，通过额外的颜色属性实现了高效的插入、删除和查找操作。红黑树的名字来源于它的...
SBTree:使用B +树优化字段的文档存储。 适配器支持内存和文件系统
05-12
SB树 使用B +树进行字段的快速文档存储。 适配器支持内存和文件系统 状态：优化，功能和稳定性正在进行中。 文档： : 该库的目标是提供一种在内存中或文件系统上快速存储基于文档的数据的方法。 它使用基于B + Tree结构的特定于字段的索引系统。 这样可以处理大量数据，并为它们建立索引，而无需将整个数据集保留在内存中。 大多数数据库使用B树（MongoDB，CouchDB）或B + Tree（InnoDB，MariaDB，MySQL）。 注意：默认情况下。 除明确排除的字段以外的所有内容都被索引。 嵌套对象也被索引。 提供了对唯一键的可选支持。 目录 常问问题 安装 npm install sbtree 发行说明 请参阅发行说明 用法 mkdir myproject cd myproject npm init npm install sbtree touch inde
SB树，看这一篇就够了
最新发布
lsd&xql的博客
09-11 288
四种违规类型得调整和AVL树一样，不一样得地方就在于谁的孩子变了，则需要重新递归调用，SB树在删除得时候可以不用去做平衡性调整，在加入节点得过程中进行平衡性调整，因为递归是具有传递性的。
SB树详解
jiangzuofengqiao的博客
05-23 865
任何一个叔叔节点上面的节点数不能小于任何一个子节点 例：（这样的排列方式使左子树和右子树相差不大） SB树在进行删除操作时先不会做调整，直到下次加入节点时再做调整。 加入节点代码 public Node insertNode(int element) { if(root == null) { root = createNode(element, null, null, null); size++; return root; } else { Node parentN
SB树和Farey序列
nameofcsdn的博客
04-05 1709
。。。
HDOJ 题目4556Stern-Brocot Tree（数学，欧拉函数）
Jogging_Clown
09-05 758
 Stern-Brocot Tree Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others) Total Submission(s): 485    Accepted Submission(s): 264 Problem Description 　　 　　
SB tree——A temporal aggregation data structure
hcy19941229的专栏
05-17 455
refer to Incremental computation and maintenance of temporal aggregates    ,Jun Yang1, JenniferWidom2 ,VLDBJ 2003
Structure.BSTree（二叉树、排序树、平衡树、SB树）
04-17 1219
Structure.BSTree
傻逼树SBT：Size Balanced Tree的实现原理，增删改查，调平衡
weixin_46838716的博客
05-29 689
为了调平衡，咱们必须要有左旋函数（leftRotate）、右旋函数（rightRotate） 调平每次变化了哪些节点，就需要再次检查和调平（maintain），maintain函数需要分LL,RR,LR,RL四种状况 查傻逼树SBT中是否有节点key，并返回离key最近的不为null的那个节点（pre），查询key函数：findLeastKeyNode 返回傻逼树SBT整体有多少个节点？size()函数 判断傻逼树是否为空树？isEmpty() put函数是更新，或者新增--没有返回值，内部操作add:ke
算法补天系列之有序表的四种实现方式——AVL树，SB树，红黑树，跳表（重点）介绍说明
weixin_51529433的博客
08-01 559
平衡性标准每一个节点不是红，就是黑，规定头和叶子结点（这里有大病，他的叶子结点是没有孩子的节点往下一层的空的那一层）必须为黑，任何两个红节点不能相邻。SB树要求每一棵字树的大小，不小于自己兄弟节点的最大的孩子节点的子树的大小。•我们来看这个插入，首先，我们来到20，因为70没有这一层，所有内部下移到第四层，然后右移到50，然后继续下移，到70有的一层，插入进去。•假如说，我们又来了一个四，假如说4的层数是2.那我们就从最高层开始找，找完了发现4没有这一层，往下走，找到层数，大小都对的位置，插入。...
二叉树专题(平衡二叉排序树 AVL树 红黑树 SB树 跳表)
eck_燃的博客
02-21 892
二叉树 二叉排序树 二叉排序树有很多优秀的性质，它可以让搜索变成logN级别的。 但是它会有极端的情况比如因为插入顺序造成的左斜树和右斜树。它的查找效率就会变和链表一样了。而引入平衡的概念，就会让它始终保持最优级别的操作。 平衡二叉树 就是它及它的子树左右两边高度差不超过1的树，注意，我们平时说的平衡二叉排序树指的是AVL树，这是平衡二叉排序树最经典的结构。红黑树，还有Size Bala...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值