splay tree.java_伸展树--java

最新推荐文章于 2023-12-20 12:45:49 发布
最新推荐文章于 2023-12-20 12:45:49 发布
阅读量187 收藏
点赞数
文章标签： splay tree.java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36285931/article/details/114142935
版权

文字转载自：http://www.cnblogs.com/vamei

代码转载自：http://www.blogjava.net/javacap/archive/2007/12/19/168627.html

我们讨论过，树的搜索效率与树的深度有关。二叉搜索树的深度可能为n，这种情况下，每次搜索的复杂度为n的量级。AVL树通过动态平衡树的深度，单次搜索的复杂度为log(n) (以上参考纸上谈兵 AVL树)。我们下面看伸展树(splay tree)，它对于m次连续搜索操作有很好的效率。

伸展树会在一次搜索后，对树进行一些特殊的操作。这些操作的理念与AVL树有些类似，即通过旋转，来改变树节点的分布，并减小树的深度。但伸展树并没有AVL的平衡要求，任意节点的左右子树可以相差任意深度。与二叉搜索树类似，伸展树的单次搜索也可能需要n次操作。但伸展树可以保证，m次的连续搜索操作的复杂度为mlog(n)的量级，而不是mn量级。

具体来说，在查询到目标节点后，伸展树会不断进行下面三种操作中的一个，直到目标节点成为根节点 (注意，祖父节点是指父节点的父节点)

1. zig: 当目标节点是根节点的左子节点或右子节点时，进行一次单旋转，将目标节点调整到根节点的位置。

0f60b9e14bb784633e5e6c160f6ac941.png

zig

2. zig-zag: 当目标节点、父节点和祖父节点成"zig-zag"构型时，进行一次双旋转，将目标节点调整到祖父节点的位置。

c7f27b26858d1da3e2ca35b4f3904cf0.png

zig-zag

3. zig-zig：当目标节点、父节点和祖父节点成"zig-zig"构型时，进行一次zig-zig操作，将目标节点调整到祖父节点的位置。

046f480fd64766a09ca28da5103fc017.png

zig-zig

单旋转操作和双旋转操作见AVL树。下面是zig-zig操作的示意图:

c3b764bdeeb10f166f55add9a24ddbfb.png

zig-zig operation

在伸展树中，zig-zig操作(基本上)取代了AVL树中的单旋转。通常来说，如果上面的树是失衡的，那么A、B子树很可能深度比较大。相对于单旋转(想一下单旋转的效果)，zig-zig可以将A、B子树放在比较高的位置，从而减小树总的深度。

下面我们用一个具体的例子示范。我们将从树中搜索节点2：

728f88566b65bdcd13bbf21e9cfb480b.png

Original

3676680ea3cbe9326ac7946604fce771.png

zig-zag (double rotation)

7cae8c6dca92ad897788361b532c1888.png

zig-zig

d233521b023e62de8d2c882638a1d94e.png

zig (single rotation at root)

上面的第一次查询需要n次操作。然而经过一次查询后，2节点成为了根节点，树的深度大减小。整体上看，树的大部分节点深度都减小。此后对各个节点的查询将更有效率。

伸展树的另一个好处是将最近搜索的节点放在最容易搜索的根节点的位置。在许多应用环境中，比如网络应用中，某些固定内容会被大量重复访问(比如江南style的MV)。伸展树可以让这种重复搜索以很高的效率完成。

java代码：

8f900a89c6347c561fdf2122f13be562.png

961ddebeb323a10fe0623af514929fc1.png

packagealgorithms.tree;/***@authoryovn

**/

public class SplayTree> extends DefaultBSTree implements BSTree{static class SplayTreeNode> extends BSTNode{

SplayTreeNodeparent;

SplayTreeNode(SplayTreeNodeparent,E key) {super(key);this.parent=parent;

}

}

@Overridepublic booleandelete(E ele) {return _delete((SplayTreeNode)root,ele);

}private boolean _delete(SplayTreeNodepointer, E ele) {int cmp=ele.compareTo(pointer.key);while(cmp!=0)

{if(cmp<0)

{

pointer=(SplayTreeNode)pointer.left;

}else{

pointer=(SplayTreeNode)pointer.right;

}if(pointer==null)return false;

cmp=ele.compareTo(pointer.key);

}//okay find it

SplayTreeNode p=pointer.parent;if(pointer.left==null)

{if(p!=null)

{

keep_right(pointer);

splay(p);

}else{

root=p.right;if(root!=null)((SplayTreeNode)root).parent=null;

}

}else if(pointer.right==null)

{if(p!=null)

{

keep_left(pointer);

splay(p);

}else{

root=p.left;if(root!=null)((SplayTreeNode)root).parent=null;

}

}else{

SplayTreeNode todo=(SplayTreeNode)pointer.left;

SplayTreeNode todoP=null;while(todo.right!=null)

{

todoP=todo;

todo=(SplayTreeNode)todo.right;

}

pointer.key=todo.key;if (todoP != null) {

todoP.right=todo.left;if (todo.left != null)

((SplayTreeNode) todo.left).parent =todoP;

}else{

pointer.left=null;

}

splay(pointer.parent);

}return true;

}private void keep_left(SplayTreeNodepointer) {

SplayTreeNode p=pointer.parent;if(p.left==pointer)

{

p.left=pointer.left;if(p.left!=null)((SplayTreeNode)p.left).parent=p;

}else if(p.right==pointer)

{

p.right=pointer.left;if(p.right!=null)((SplayTreeNode)p.right).parent=p;

}

}private void keep_right(SplayTreeNodepointer) {

SplayTreeNode p=pointer.parent;if(p.left==pointer)

{

p.left=pointer.right;if(p.left!=null)((SplayTreeNode)p.left).parent=p;

}else if(p.right==pointer)

{

p.right=pointer.right;if(p.right!=null)((SplayTreeNode)p.right).parent=p;

}

}protected void splay(SplayTreeNodecur) {if(cur==null)return;while(cur!=root)

{if(cur.parent==root)

{//single Rotation

SingleRotation(cur,cur.parent);

cur.parent=null;

root=cur;

}else if(cur.parent.left==cur&&cur.parent.parent.left==cur.parent)

{

cur=Left_ZigZig(cur,cur.parent,cur.parent.parent);

}else if(cur.parent.right==cur&&cur.parent.parent.right==cur.parent)

{

cur=Right_ZigZig(cur,cur.parent,cur.parent.parent);

}else if(cur.parent.left==cur&&cur.parent.parent.right==cur.parent)

{

cur=RL_ZigZag(cur,cur.parent,cur.parent.parent);

}else if(cur.parent.right==cur&&cur.parent.parent.left==cur.parent)

{

cur=LR_ZigZag(cur,cur.parent,cur.parent.parent);

}else{

System.out.println("Oooops!!!");

}

}

}private SplayTreeNode LR_ZigZag(SplayTreeNodecur,

SplayTreeNode p, SplayTreeNodeg) {

SplayTreeNode gp=g.parent;

g.left=cur.right;

setParent(cur.right,g);

g.parent=cur;

cur.right=g;

p.right=cur.left;

setParent(cur.left,p);

p.parent=cur;

cur.left=p;if(gp!=null)

{if(gp.left==g)

{

gp.left=cur;

}else{

gp.right=cur;

}

}else root=cur;

cur.parent=gp;returncur;

}private SplayTreeNode RL_ZigZag(SplayTreeNodecur,

SplayTreeNode p, SplayTreeNodeg) {

SplayTreeNode gp=g.parent;

g.right=cur.left;

setParent(cur.left,g);

g.parent=cur;

cur.left=g;

p.left=cur.right;

setParent(cur.right,p);

p.parent=cur;

cur.right=p;if(gp!=null)

{if(gp.left==g)

{

gp.left=cur;

}else{

gp.right=cur;

}

}else root=cur;

cur.parent=gp;returncur;

}protected SplayTreeNode Right_ZigZig(SplayTreeNode cur, SplayTreeNodep,

SplayTreeNodeg) {

SplayTreeNode gp=g.parent;

g.right=p.left;

setParent(p.left,g);

p.right=cur.left;

setParent(cur.left,p);

g.parent=p;

p.left=g;

p.parent=cur;

cur.left=p;if(gp!=null)

{if(gp.left==g)

{

gp.left=cur;

}else{

gp.right=cur;

}

}else root=cur;

cur.parent=gp;returncur;

}protected SplayTreeNode Left_ZigZig(SplayTreeNode cur, SplayTreeNodep,

SplayTreeNodeg) {

SplayTreeNode gp=g.parent;

g.left=p.right;

setParent(p.right,g);

g.parent=p;

p.right=g;

p.left=cur.right;

setParent(cur.right,p);

p.parent=cur;

cur.right=p;if(gp!=null)

{if(gp.left==g)

{

gp.left=cur;

}else{

gp.right=cur;

}

}else root=cur;

cur.parent=gp;returncur;

}final void setParent(BSTNode c, BSTNodep) {if(c!=null)((SplayTreeNode)c).parent=(SplayTreeNode)p;

}private void SingleRotation(SplayTreeNode cur, SplayTreeNodep) {if(p.left==cur)

{

p.left=cur.right;if(cur.right!=null)((SplayTreeNode)cur.right).parent=p;

cur.right=p;

p.parent=cur;

}else if(p.right==cur)

{

p.right=cur.left;if(cur.left!=null)((SplayTreeNode)cur.left).parent=p;

cur.left=p;

p.parent=cur;

}

}

@Overridepublic voidinsert(E ele) {if (root == null) {

root= new SplayTreeNode(null,ele);return;

}

_insert((SplayTreeNode)root,ele);

}private final void _insert(SplayTreeNodepointer,E ele)

{int cmp=pointer.key.compareTo(ele);if(cmp==0)

{throw newIllegalArgumentException();

}if(cmp>0)

{if(pointer.left==null)

{

pointer.left=new SplayTreeNode(pointer,ele);

splay((SplayTreeNode)pointer.left);return;

}

_insert((SplayTreeNode)pointer.left,ele);

}else{if(pointer.right==null)

{

pointer.right=new SplayTreeNode(pointer,ele);

splay((SplayTreeNode)pointer.right);return;

}

_insert((SplayTreeNode)pointer.right,ele);

}

}

@Overridepublic booleansearch(E ele) {return _search((SplayTreeNode)root,ele);

}private boolean _search(SplayTreeNodepointer, E ele) {if(pointer==null)return false;int cmp=pointer.key.compareTo(ele);if(cmp==0)

{

splay(pointer);return true;

}if(cmp>0)

{return _search((SplayTreeNode)pointer.left,ele);

}else{return _search((SplayTreeNode)pointer.right,ele);

}

}/****/

publicSplayTree() {

}

}

伸展树java代码

一笑逢
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
splaytree.zip
04-23
展树（Splay Tree）是一种二叉搜索树，它能在O(log n)内完成插入、查找和删除操作。它由Daniel Sleator和Robert Tarjan创造。它的优势在于不需要记录用于平衡树的冗余信息。在伸展树上的一般操作都基于伸展操作。
splay tree.java_伸展树--Java实现
weixin_36124888的博客
02-13 331
前言前面的学习中，笔者就二叉树、二叉查找树、平衡二叉树进行了一些总结。此篇文章主要讨论伸展树。我们知道的是在二叉查找树上的基本操作(查找、插入)的时间复杂读与树的高度成正比的关系。对于一个含有N个结点的二叉查找树来说，这些操作的最坏运行情况为OlogN)。但是我们这知道在极端的情况下，会导致树退化为一个单支树，这导致了操作时间为O(N)。为了克服上面的情况，出现了一些二叉查找树的变形，例如上篇文章...
纸上谈兵: 伸展树 (splay tree)
weixin_30627381的博客
03-24 97
作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！ 我们讨论过，树的搜索效率与树的深度有关。二叉搜索树的深度可能为n，这种情况下，每次搜索的复杂度为n的量级。AVL树通过动态平衡树的深度，单次搜索的复杂度为log(n) (以上参考纸上谈兵 AVL树)。我们下面看伸展树(splay tree)，它对于m次连续搜索操作有很好的...
Splay
ID246783的博客
03-06 3157
Spaly   众所周知，Splay 是一种平衡二叉查找树（不要告诉我你不知道二叉查找树是什么qwq 不知道什么是二叉查找树的看过来： 关于二叉查找树）。在这篇东西的最后我们也解释了为什么我们需要用到平衡二叉查找树而不是直接查找，这里就不再赘述了，所以现在直接引入正题吧。 旋转操作   未来解决普通二叉查找树被卡成层数过深而时间复杂度升高的问题我们需要引入这样一个旋转操作。这个操作的本质就是在不改变这棵树的中序遍历的前提下让这颗树的层数减小。具体来说是这样做的（对于左边的那棵树：RRR 是 yyy 的祖先
Java基础 - 伸展树（SplayTree）
ApatheCrazyFan的博客
12-05 1937
伸展树的基本操作有： 1.查询 2.添加 3.删除 4.树的最大节点 5.树的最小节点 6.节点的前驱 7.节点的后继 8.合并 9.分离 下面是我完成的部分功能代码（除节点的后继，大家可以仿照求节点的前驱的方法来求后继，很简单）： package com.yc.tree; import java.util.ArrayDeque; import java.util.Arra
splay tree java_伸展树(splay tree)自顶向下的算法
weixin_36210111的博客
02-21 412
伸展树(splay tree)是一种能自我调整的二叉搜索树(BST)。虽然某一次的访问操作所花费的时间比较长，但是平摊(amortized)之后的访问操作(例如旋转)时间能达到O(logn)的复杂度。对于某一个被访问的节点，在接下来的一段时间内再次频繁访问它(90%的情况下是这样的，即符合90-10规则，类似于CPU内或磁盘的cache设计原理)的应用模式来说，伸展树是一种很理想的数据结构。这是因...
splay-tree：快速的splay-tree数据结构
02-05
快速八叉树 ：（非递归）和简单（<1000行代码）实现是直接从Wikipedia改编而成的，使用与相同的API来针对其他树运行基准测试。 该树基于D.Sleator自上而下的展开...S splaytree import SplayTree from 'splaytree'
erl-splay-tree：Erlang中的splay-tree实现
02-05
erl-splay-tree：Erlang中的splay-tree实现
数据结构伸展树splay.rar
07-16
伸展树（Splay Tree），也叫分裂树，是一种二叉排序树，它能在O(log n)内完成插入、查找和删除操作。它由丹尼尔·斯立特Daniel Sleator 和 罗伯特·恩卓·塔扬Robert Endre Tarjan 在1985年发明的。 [1] 在伸展树上...
Algorithm-splay_tree.zip
09-17
Algorithm-splay_tree.zip,具有摊销访问权的自平衡二叉树,算法是为计算机程序高效、彻底地完成任务而创建的一组详细的准则。
平衡树详解（Splay）
Wu_while的博客
08-29 1万+
引入 先看例题：（洛谷 P3369 【模板】普通平衡树） 您需要写一种数据结构，来维护一些数，其中需要提供以下操作： 1.插入 xxx 数 2.删除 xxx 数(若有多个相同的数，因只删除一个) 3.查询 xxx 数的排名(排名定义为比当前数小的数的个数 +1+1+1 ) 4.查询排名为 xxx 的数 5.求 xxx 的前驱(前驱定义为小于 xxx，且最大的数) 6.求 xxx 的后继(后继定义为大于 xxx，且最小的数) 显然可以使用BST（二叉搜索树）完成，它的时间复杂度是 O(logn)O(log
Splay基础操作
playedgames的博客
09-25 256
Splay作为平衡树的基础操作
【笔记】Splay 详细解读
最新发布
星河依旧长明的博客
12-20 1445
Splay 是一种平衡树，并且是一棵二叉搜索树（BST）。它满足对于任意节点，都有左子树上任意点的值 < 当前节点的值 < 右子树上任意点的值。优点：支持多种操作。缺点：常数较大。单次操作均摊复杂度Olog⁡nO(\log n)Ologn。(注：关于 Splay 单次操作均摊复杂度的证明见OI-WikiSplay 基于旋转操作维护树的平衡。旋转分为左旋 (zag) 和右旋 (zig)。旋转，即在保证平衡树中序遍历不变的前提下，改变整个树的深度。
splay入门教程
weixin_30247781的博客
02-27 170
笔者一个数据结构的蒟蒻还是奇迹般的搞明白了splay的基本原理以及实现方法，所以写下这篇随笔希望能帮到像我当初一脸懵逼的人。 我们从二叉查找树开始说起： 二叉查找树是一棵二叉树，它满足这样一个性质：所有小于当前节点的点都在该节点的左子树上，所有大于当前节点的点都在该节点的右子树上。对于和当前节点一样大的点，我们有两种方法，一种是直接默认它到右子树上去，但是这样会造成空间的浪费。我们有一种...
平衡树(Splay) 服务:第一弹——旋转的艺术
artalter的博客
03-20 758
平衡树(Splay) 服务:第一弹——旋转的艺术 0.前言 本蒟蒻前不久刚学SPLAY，有了一点心得，想要巩固下来。同时也觉得网上的神犇们实在太强了，有的内容并不能很好的让我这样的蒟蒻理解，因此便有了我这篇RBQ级服务的博客。我的splay是看自有风月马前卒学的，因此部分代码可能有些相似。自有风月马前卒是一位高产的神犇，强烈推荐大家看他的博客 1.引入：何为平衡树 平衡树，大家一定都听说过（毕竟没听说过也不会来找Splay博客），那么，平衡树到底是怎么回事呢？就让小编一起带大家来看看吧 平衡树是一种 二叉搜
splay详解（一）
weixin_34227447的博客
11-25 159
前言 Spaly是基于二叉查找树实现的， 什么是二叉查找树呢？就是一棵树呗:joy: ,但是这棵树满足性质—一个节点的左孩子一定比它小，右孩子一定比它大 比如说 这就是一棵最基本二叉查找树 对于每次插入，它的期望复杂度大约是$logn$级别的，但是存在极端情况，比如9999999 9999998 9999997.....1这种数据，会直接被卡成$n^2$ 在这种情况下，平衡树出现了...
伸展树(Splay tree)图解与实现
热门推荐
小张的专栏
11-02 3万+
个人技术博客：http://blog.ztgreat.cn 一、伸展树    本文介绍了二叉查找树的一种改进数据结构–伸展树（Splay Tree）。它的主要特点是不会保证树一直是平衡的，但各种操作的平摊时间复杂度是O(log n)，因而，从平摊复杂度上看，二叉查找树也是一种平衡二叉树。另外，相比于其他树状数据结构（如红黑树，AVL树等），伸展树的空间要求与编程复杂度要小得多。 伸展树...
【数据结构与算法】伸展树的Java实现
星拱北辰的博客
02-26 1033
Java编写一个伸展树，含比较器
link-cut-tree
05-18
LCT 的核心是 Splay Tree，一种自平衡二叉搜索树，它可以在 O(logn) 的时间内实现树上路径操作。在 Splay Tree 的基础上，LCT 通过维护一些附加信息（如子树大小、父亲节点等）来实现树上路径操作。 LCT 可以用于...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值