数据结构 - 伸展树 Splay Tree

最新推荐文章于 2024-04-16 16:04:15 发布
最新推荐文章于 2024-04-16 16:04:15 发布
阅读量789 收藏 7
点赞数 2
分类专栏： 数据结构 文章标签： 伸展树 自顶向下
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y109y/article/details/87887969
版权

目录

一、什么是伸展树？

80-20黄金法则显示，日常中我们80%的访问发生在20%的数据上。

如果我们能够把经常访问的节点推到靠近根节点的位置，那么就可以极大的提高访问速度。

这就是伸展树的出发点，并实现了以下方案：每次查找节点之后对树进行重构（旋转操作），把被查找的节点搬移到树根。

与二叉平衡树相比，伸展树不会保证树一直是平衡的，甚至可能是一个糟糕的单链表，但是它各种操作的平摊时间复杂度是O(log n)。

二、Splay操作的设计模式

伸展树的设计有两种设计模式，一种“自底向上”，一种“自顶向下”。

由于伸展树的操作需要访问其父结点和祖父结点，那么“自底向上”的设计就需要额外的指针指向结点的父结点，来为我们提供访问的方式，这就需要额外的空间了。

//自底向上
struct SplayNode{
	int value;
	SplayNode *parent; //额外指针指向父结点
	SplayNode *left, *right;
	SplayNode(int val):value(val), left(NULL), right(NULL){}
};

因此本文主要讨论“自顶向下”的模式，因此延展树的定义如下。

//自顶向下
struct SplayNode{
	int value;
	SplayNode *left, *right;
	SplayNode(int val):value(val), left(NULL), right(NULL){}
};

class SplayTree{
public:
	SplayTree(): root(NULL){}
	SplayTree(vector<int> &arr);
	void Splay(int val);
	//....
private:
	//....
	SplayNode* root;
};

三、伸展树的旋转操作

假设X是一个非根点的被访问结点：

  • 如果X的父结点是root，那我们可以直接旋转X和root。
  • 如果X除了有父结点P，还有一个祖父结点G，那么就有两种情景（实际是四种，但是镜像），分别为Zig-Zag和Zig-Zig。

3.1 父结点是root

3.1.1 左旋

访问结点X在父结点的左边，旋转操作：P的左子树挂载X的右子树，然后P成为X的右子树。

在这里插入图片描述

SplayNode* SplayTree::LeftRotation(SplayNode* G){
	SplayNode* X = G->left;
	G->left = X->right;
	X->right = G;
	return X;
}
3.1.2 右旋

访问结点X在父结点P的右边，旋转操作：P的右子树挂载X的左子树，然后P成为X的左子树。

在这里插入图片描述

SplayNode* SplayTree::RightRotation(SplayNode* G){
	SplayNode* X = G->right;
	G->right = X->left;
	X->left = G;
	return X;
}

3.2 父结点不是root

如果父结点P不是root，那么X除了有父结点P，还有一个祖父结点G，那么就有两种情景（实际是四种，但是镜像），分别为Zig-Zag和Zig-Zig。

3.2.1 Zig-Zig

下图是Zig-Zig中左-左的情形（右-右类似），可以看出需要做两次旋转。

  • 第一次，把P和X看成一个整体，对G和(P, X)做一次左旋操作。
  • 第二次，把P和G看出一个整体，对X和(P, G)做一次左旋操作。

在这里插入图片描述

3.2.2 Zig-Zag

下图是Zig-Zag中左-右的情形（右-左类似），也需要两次旋转，不过方式不一样。

  • 第一次，以P为root结点，对P和X做一次右旋操作。
  • 第二次，把P和X看成一个整体，对G和(P, X)做一次左旋操作。

在这里插入图片描述

实现

因为，本文主要讨论“自顶向下”的模式。结合前面关于旋转的讨论，Splay操作的实现如下。

void SplayTree::SpecificSplay(int val, SplayNode* &T){
	if(!T) return;
	if(val == T->value) return;

	SplayNode* G = T;
	for(;;){
		if(val < G->value){
			if(!G->left) break;
			if(val < G->left->value){ //left zig-zig
				G = LeftRotation(G);
			}
			else if(val > G->left->value){ //left zig-zag
				G->left = RightRotation(G->left);
			}

			G = LeftRotation(G);
		}
		else if(val > G->value){
			if(!G->right) break;

			if(val < G->right->value){ //right zig-zag
				G = LeftRotation(G);
			}
			else if(val > G->right->value){ //right zig-zig
				G = RightRotation(G);
			}
			G = RightRotation(G);
		}
		else break;
	}

	T = G;
}

四、删除操作

相较于其他操作，伸展树的删除操作比较特殊，它主要包括以下步骤：

  • 将待删除元素结点splay到root，然后delete。
  • 将左子树leftTree中最大值结点splay到左子树的root
  • 将右子树rightTree挂载到leftTree->right上。

实现如下：

SplayNode* SplayTree::getMax(SplayNode* T){
	if(!T) return NULL;
	if(!T->right) return T;
	else return getMax(T->right);
}

void SplayTree::Delete(int val){
	if(!root) return;
	SpecificSplay(val, root);
	SplayNode *leftTree = root->left, *rightTree = root->right;
	SplayNode *leftTreeMax = getMax(root->left);//左子树最大值

	delete root;

	if(!leftTreeMax)  
		root = rightTree;
	else{
		SpecificSplay(leftTreeMax->value, leftTree);
		leftTree->right = rightTree;
		root = leftTree;
	}
}

五、完整程序

SplayTree.h
#pragma once
#include <vector>
using namespace std;

/* 伸展树 Splay Tree
 * ADT和AVL都不能保证分摊时间(amortized time)始终保持在O(logN)，而伸展树可以。
*/

struct SplayNode{
	int value;
	SplayNode *left, *right;
	SplayNode(int val):value(val), left(NULL), right(NULL){}
};

class SplayTree{
public:
	SplayTree(): root(NULL){}
	SplayTree(vector<int> &arr);
	void Insert(int val);
	void Delete(int val);
	void PostOrder();
	void Splay(int val);
	void Clear();
private:
	SplayNode* LeftRotation(SplayNode* G); //X从右子树旋到根结点
	SplayNode* RightRotation(SplayNode* G); //X从左子树旋转到根结点
	SplayNode* RecursiveInsert(int val, SplayNode* T);
	SplayNode* RecursiveClear(SplayNode* T);
	SplayNode* getMax(SplayNode* T);
	void SpecificSplay(int val, SplayNode* &T);
	void RecursivePostOrder(SplayNode* T);
	SplayNode* root;
};
SplayTree.cpp
#include "SplayTree.h"
#include <algorithm>
#include <iostream>
using namespace std;

SplayTree::SplayTree(vector<int> &arr){
	for(auto &i: arr)
		Insert(i);
}

void SplayTree::Insert(int val){
	root = RecursiveInsert(val, root);
}

SplayNode* SplayTree::RecursiveInsert(int val, SplayNode* T){
	if(!T) return new SplayNode(val);
	if(val > T->value)
		T->right = RecursiveInsert(val, T->right);
	else if(val < T->value)
		T->left = RecursiveInsert(val, T->left);
	else {cout << "This node already exits." << endl;}
	return T;
}

SplayNode* SplayTree::getMax(SplayNode* T){
	if(!T) return NULL;
	if(!T->right) return T;
	else return getMax(T->right);
}

void SplayTree::Delete(int val){
	if(!root) return;
	SpecificSplay(val, root);
	SplayNode *leftTree = root->left, *rightTree = root->right;
	SplayNode *leftTreeMax = getMax(root->left);//左子树最大值

	delete root;

	if(!leftTreeMax)  
		root = rightTree;
	else{
		SpecificSplay(leftTreeMax->value, leftTree);
		leftTree->right = rightTree;
		root = leftTree;
	}
}

void SplayTree::PostOrder(){
	RecursivePostOrder(root);
}

void SplayTree::RecursivePostOrder(SplayNode* T){
	if(!T) {return;}
	RecursivePostOrder(T->left);
	RecursivePostOrder(T->right);
	cout << T->value << " ";
}

 /*
  * X一开始处于左子树
  *               G                X
  *              /                /  \
  *             X     ==>      left   G
  *           /   \                  /
  *         left right            right
  */
SplayNode* SplayTree::LeftRotation(SplayNode* G){
	SplayNode* X = G->left;
	G->left = X->right;
	X->right = G;
	return X;
}


/*
 * X一开始处于右子树:
 * 
 *             G                   X
 *            /  \                /  \
 *         left1  X    ==>       G  right
 *              /   \          /   \ 
 *           left2 right    left1  left2 
 */
SplayNode* SplayTree::RightRotation(SplayNode* G){
	SplayNode* X = G->right;
	G->right = X->left;
	X->left = G;
	return X;
}

void SplayTree::Splay(int val){
	SpecificSplay(val, root);
}

void SplayTree::SpecificSplay(int val, SplayNode* &T){
	if(!T) return;
	if(val == T->value) return;

	SplayNode* G = T;
	for(;;){
		if(val < G->value){
			if(!G->left) break;
			if(val < G->left->value){
				G = LeftRotation(G);
			}
			else if(val > G->left->value){
				G->left = RightRotation(G->left);
			}

			G = LeftRotation(G);
		}
		else if(val > G->value){
			if(!G->right) break;

			if(val < G->right->value){
				G = LeftRotation(G);
			}
			else if(val > G->right->value){
				G = RightRotation(G);
			}
			G = RightRotation(G);
		}
		else break;
	}

	T = G;
}

void SplayTree::Clear(){
	root = RecursiveClear(root);
}

SplayNode* SplayTree::RecursiveClear(SplayNode* T){
	if(!T) return NULL;
	T->left = RecursiveClear(T->left);
	T->right = RecursiveClear(T->right);
	delete T; T = NULL;
	return T;
}
main.cpp
#include "SplayTree.h"
#include <iostream>
using namespace std;

int main(){
	vector<int> arr = {10, 6, 8, 4, 5, 3, 11};
	SplayTree test(arr);

	//Insertion Test
	cout << "After Insertion: ";
	test.PostOrder(); cout << endl;
	cout << endl;

	//Splay Test 1: Left Zig-Zag
	test.Splay(8);
	cout << "First Splaying: ";
	test.PostOrder(); cout << endl;

	//Splay Test 2: Left Zig
	test.Splay(6);
	cout << "Second Splaying: ";
	test.PostOrder(); cout << endl;

	//Splay Test 3: Left Zig-Zig
	test.Splay(3);
	cout << "Third Splaying: ";
	test.PostOrder(); cout << endl;

	//Splay Test 4: Right Zig-Zig + Left Zig-Zag
	test.Splay(5);
	cout << "Fourth Splaying: ";
	test.PostOrder(); cout << endl;	

	//Splay Test 5: Right Zig
	test.Splay(6);
	cout << "Fifth Splaying: ";
	test.PostOrder(); cout << endl;	

	//Insert 9 for Test 5
	cout << endl;
	test.Insert(9);
	cout << "Insert 9: ";
	test.PostOrder(); cout << endl;	
	cout << endl;

	//Splay Test 5: Right Zig-Zig + Right Zig-Zag
	test.Splay(9);
	cout << "Sixth Splaying: ";
	test.PostOrder(); cout << endl;	

	//Deletion Test
	cout << "After Deletion: ";
	test.Delete(6);
	test.PostOrder(); cout << endl;

	//Clearing Test
	cout << "After Clearing: ";
	test.Clear();
	test.PostOrder(); cout << endl;
}
Output
After Insertion: 3 5 4 8 6 11 10

First Splaying: 3 5 4 6 11 10 8
Second Splaying: 3 5 4 11 10 8 6
Third Splaying: 5 11 10 8 6 4 3
Fourth Splaying: 3 4 11 10 8 6 5
Fifth Splaying: 3 4 5 11 10 8 6

Insert 9: 3 4 5 9 11 10 8 6

Sixth Splaying: 3 4 5 6 8 11 10 9
After Deletion: 3 4 11 10 9 8 5
After Clearing:

六、更多思考

虽然伸展树在性能上超过了二叉平衡树，但是由于“二叉”这个局限，其对于大块数据的读写仍显得心有余而力不足。

自然而然，我们就可以想到“多叉”，B树就是一个类似于“多叉”的树结构，它减少了定位记录时所经历的中间过程，从而加快存取速度。

奶罐
关注
专栏目录
树学习 ---------伸展树（splay Tree）
杨鑫newlife的专栏
11-24 1213
伸展树（Splay Tree），也叫分裂树，是一种二叉排序树，它能在O(log n)内完成插入、查找和删除操作。 它由Daniel Sleator和Robert Tarjan创造，后者对其进行了改进。它的优势在于不需要记录用于平衡树的冗余信息。在伸展树上的一般操作都基于伸展操作。
Splay Tree伸展树
Shine__Wong的博客
10-24 454
伸展树基本概念 伸展树的基本思想。 伸展树完全是基于局部性原理(locality)的。 局部性原理是计算机科学中非常重要的原理，很多设计，比如说多级存储器，缓存，都是基于局部性原理。简单说来就是<刚访问过的数据，在一段时间内极有可能再次被访问>。因此，对于物理存储器而言，会将刚刚访问过的数据，转移存储到更高级的存储介质中，比如内存或者缓存，以便下次访问这些数据时可以高效地进行。而对...
伸展树
weixin_34203832的博客
03-17 238
一、简介：伸展树，或者叫自适应查找树，是一种用于保存有序集合的简单高效的数据结构。伸展树实质上是一个二叉查找树。允许查找，插入，删除，删除最小，删除最大，分割，合并等许多操作，这些操作的时间复杂度为O(logN)。由于伸展树可以适应需求序列，因此他们的性能在实际应用中更优秀。伸展树支持所有的二叉树操作。伸展树不保证最坏情况下的时间复杂度为O(logN)。伸展树的时间复杂度边界是均摊的。尽管一个单独...
6天通吃树结构—— 第四天 伸展树
weixin_34054931的博客
08-04 162
        我们知道AVL树为了保持严格的平衡，所以在数据插入上会呈现过多的旋转，影响了插入和删除的性能，此时AVL的一个变种 伸展树（Splay）就应运而生了，我们知道万事万物都遵循一个“八二原则“，也就是说80%的人只会用到20%的数据，比如说我们 的“QQ输入法”，平常打的字也就那么多，或许还没有20%呢。   一：伸展树  1：思想     伸展树的原理就是这样的一个”八...
数据结构伸展树splay.rar
07-16
伸展树（Splay Tree），也叫分裂树，是一种二叉排序树，它能在O(log n)内完成插入、查找和删除操作。它由丹尼尔·斯立特Daniel Sleator 和 罗伯特·恩卓·塔扬Robert Endre Tarjan 在1985年发明的。 [1] 在伸展树上...
伸展树SplayTree：一种自调整二叉排序树
"伸展树(Splay Tree)是一种自调整的二叉排序树，由Daniel Sleator和Robert Tarjan提出。这种数据结构能在O(logn)的时间复杂度内完成插入、查找和删除操作，并且不需要像其他平衡二叉树那样维护额外的平衡信息。伸展...
向下延伸树控件_寿县：生命之树—记家乡百年麻栎树
weixin_31556767的博客
01-03 395
播放向上滑动阅览生命之树—记家乡百年麻栎树文/沈庆功上午时分，碧空如洗，万里无云。我独自一人骑着电动车来到寿县炎刘镇磨湾村九家组—来看望我的“老朋友”—一棵120年左右树龄的麻栎树。因为这棵“神树”是我童年的回忆！ 九家大树起田垄，曾经霜雪几千重；春来已吐满枝绿，冬至再添一树红。有人说九家大树在寿县城墙上可以隐约看到，反正我不太相信。但在炎刘镇新桥村是可以看到它的存在的！...
伸展树(splay tree)
weixin_30611509的博客
10-16 583
对于二叉查找树而言，每次操作的最坏时间复杂度是O(N)。（当树退化为链表的时候）。为了解决这个问题，我们给树附加了一个平衡条件。平衡条件限制了任何节点的深度都不能过深。其中一种限制条件是：一颗二叉查找树的左子树和右子树的高度差不能超过1，这个条件限制产生了AVL树。 二叉查找树的最坏操作是O(N)。但是这样的操作并不常见。所以累加起来的时间就变得比单次操作时间的...
数据结构与算法分析之伸展树(splaytree)
mu0206mu的专栏
04-15 6630
1.伸展树，它保证从空树开始任意连续M次对树的操作最多花费O(MlogN)的时间。 2.伸展树的基本思想是，当一个节点a被访问后，通过一系列的AVL树的旋转将a移动到根节点上，这样下次访问时会被快速击中 只需要O(1)的时间。通常一个节点被访问时，它就很可能不久再次被访问。 3.构造伸展树的一个简单方法是从下向上进行单旋转，也就是将访问路径上的每个节点和他们的父节点都实施旋转
伸展树-搜索树
最新发布
lq
04-16 949
/ 因为根节点被删除了，搜索会将右子树中节点值最接近查找数值的节点返回，这个节点就是右子树中最小的节点，然后右子树中最小节点必伸展至根，且（因无类同节点）其左子树必空。// 根节点 = 其右子树，也就是原本的根节点已经被删除了。在这种情况中，X有一个父节点P和祖父节点G（P的父节点）。// 令 新的根节点左子树 = 上面存储的左子树。存在，此时有一个隐含信息，因为搜索到了该节点，那么这个节点此时已经被伸展到树根了。关于查询操作中，将节点伸展至根节点的操作，应用伸展(splaying)技术。
伸展树（Splay Tree）尽收眼底
qiudesuo的专栏
10-27 310
伸展树（Splay Tree）尽收眼底     本文内容框架： §1 伸展树定义 §2 伸展树自底向上伸展   §3 伸展树自顶向下伸展 §4 伸展树基本操作，实现以及应用 §5 小结       §1 伸展树定义   伸...
九、【数据结构】伸展树(splay tree )的解析与实现
天涯明月刀的博客
12-11 1482
和之前介绍的AVL树一样，伸展树也是平衡二叉树中的一种，但是它和AVL的原理不同，相比之下，伸展树的实现更加便捷。这里先回顾一下AVL树的特点。 一、回顾AVL树的特点 AVL树保证静态查找效率的关键技巧是添加约束条件，使在任意时刻（不包含瞬时状态）树的高度始终在一个很低的范围。具体的策略是引入平衡因子的概念，以及在树失衡时，使用AVL自己的一套等效旋转技巧使树恢复平衡。 这种方案具有一定的...
伸展树详解
good good study, day day up!
05-11 596
伸展树（Splay Tree）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值