伸展树(splay tree)是一种相对简单的数据结构,它保证从空树开始任意连接次对树的操作最多花费时间。伸展树的基本思路:当一个节点被访问后,它就要经过一系列AVL树的旋转被推到根上。如果一个结点很深,那么在其路径上就存在相对较深的结点,通过重新构造可以使对所有这些结点的访问所花费的时间减少。另外,由于伸展树不要求保留高度或平衡信息,因此在某种程度上可以节约空间并简化代码。
伸展树的特点:
1)伸展树属于二叉查找树,即它具有和二叉查找树一样的性质:左子树的值小于右子树的值,递归判断依然成立;
2)除了拥有二叉查找树的性质之外,伸展树还具有的一个特点是:当某个节点被访问时,伸展树会通过旋转使该节点成为树根。这样做的好处是,下次要访问该节点时,能够迅速的访问到该节点。。
伸展树的旋转:
1)伸展树中存在键值为data的结点:将该结点旋转为根节点
2)伸展树中不存在键值为data的结点, 且data小于根节点的键值
2-1)该结点存在前驱节点(小于该结点键值的最大键值对应的结点),将前驱节点旋转为根节点
2-2)该结点不存在前驱节点,即该结点为最小值结点,将最小值旋转为根节点
3)伸展树中不存在键值为data的结点,且data大于根节点的键值
3-1)该结点存在后继结点(大于该结点键值的最小键值对应的结点),将后继结点旋转为根节点
3-2)该结点不存在后继节点,即该结点为最大值结点,将最大值旋转为根节点
之字形旋转:
一字型旋转:
实例:建立splay树,设计遍历函数、插入数据、删除数据、查找最值、打印树结构等功能。
1、splay.h
//splay.h
#ifndef SPLAY_H_
#define SPLAY_H_
#include<iostream>
#include<iomanip>
using std::cout;
using std::endl;
using std::setw;
template<class T>
struct Node{
T data;
Node *left;
Node *right;
Node():left(NULL), right(NULL){};
Node(T d, Node<T> *l, Node<T> *r):data(d), left(l), right(r){};
};
template<class T>
class Splay{
private:
Node<T> *root;
public:
//Splay constructor
Splay():root(NULL){
};
//Splay destructor
~Splay(){
destroy();
};
//preOrder
void preOrder(){
preOrder(root);
};
//inOrder
void inOrder(){
inOrder(root);
};
//postOrder
void postOrder(){
postOrder(root);
};
//Splay search without iterative
Node<T>* search(T d){
search(root, d);
};
//Splay search with iterative
Node<T>* iterativeSearch(T d){
iterativeSearch(root, d);
};
//find maximum value
T max(){
Node<T> *temp = max(root);
if(temp != NULL){
return temp -> data;
}
return (T)NULL;
};
//find minimum value
T min(){
Node<T> *temp = min(root);
if(temp != NULL){
return temp -> data;
}
return (T)NULL;
};
//splay the value
void splay(T d){
root = splay(root, d);
};
//Splay insert
void insert(T d){
Node<T> *temp = NULL;
if((temp = new Node<T>(d, NULL, NULL)) == NULL){
return;
}
//from root insert d
root = insert(root, temp);
//splay d as new root
root = splay(root, d);
};
//Splay remove
void remove(T d){
root = remove(root, d);
};
//Splay destroy
void destroy(){
destroy(root);
};
//Splay print
void print(){
if(root != NULL){
print(root, root -> data, 0);
}
};
private:
void preOrder(Node<T> *node) const;
void inOrder(Node<T> *node) const;
void postOrder(Node<T> *node) const;
Node<T>* search(Node<T> *node, T d) const;
Node<T>* iterativeSearch(Node<T> *node, T d) const;
Node<T>* min(Node<T> *node);
Node<T>* max(Node<T> *node);
Node<T>* splay(Node<T> *node, T d);
Node<T>* insert(Node<T>* &node, Node<T> *d);
Node<T>* remove(Node<T>* &node, T d);
void destroy(Node<T>* &node);
void print(Node<T> *node, T d, int direction);
};
template<class T>
void Splay<T>::preOrder(Node<T> *node) const{
if(node != NULL){
cout << node -> data << " ";
preOrder(node -> left);
preOrder(node -> right);
}
}
template<class T>
void Splay<T>::inOrder(Node<T> *node) const{
if(node != NULL){
inOrder(node -> left);
cout << node -> data << " ";
inOrder(node -> right);
}
}
template<class T>
void Splay<T>::postOrder(Node<T> *node) const{
if(node != NULL){
postOrder(node -> left);
postOrder(node -> right);
cout << node -> data << " ";
}
}
template<class T>
Node<T>* Splay<T>::search(Node<T> *node, T d) const{
if(node == NULL || d == node -> data){
return node;
}
if(d < node -> data){
search(node -> left, d);
}else{
search(node -> right, d);
}
}
template<class T>
Node<T>* Splay<T>::iterativeSearch(Node<T> *node, T d) const{
while( (node != NULL) && (d != node -> data)){
if(d < node -> data){
node = node -> left;
}
else{
node = node -> right;
}
}
return node;
}
template<class T>
Node<T>* Splay<T>::min(Node<T> *node){
if(node == NULL){
return node;
}
while(node -> left != NULL){
node = node -> left;
}
return node;
}
template<class T>
Node<T>* Splay<T>::max(Node<T> *node){
if(node == NULL){
return node;
}
while(node -> right != NULL){
node = node -> right;
}
return node;
}
template<class T>
Node<T>* Splay<T>::splay(Node<T> *node, T d){
Node<T> temp, *l ,*r, *cur;
if(node == NULL){
return node;
}
temp.left = temp.right = NULL;
l = r = &temp;
for(;;){
if(d < node -> data){
//right rotation
if(node -> left == NULL){
break;
}
if(d < node -> left -> data){
cur = node -> left;
node -> left = cur -> right;
cur -> right = node;
node = cur;
if(node -> left == NULL){
break;
}
}
//link right
r -> left = node;
r = node;
node = node -> left;
}else if(d > node -> data){
if(node -> right == NULL){
break;
}
//left rotation
if(d > node -> right -> data){
cur = node -> right;
node -> right = cur -> left;
cur -> left = node;
node = cur;
if(node -> right == NULL){
break;
}
}
//link left
l -> right = node;
l = node;
node = node -> right;
}else{
break;
}
}
//assemble
l -> right = node -> left;
r -> left = node -> right;
node -> left = temp.right;
node -> right = temp.left;
return node;
}
template<class T>
Node<T>* Splay<T>::insert(Node<T>* &node,Node<T> *d){
Node<T> *temp1 = NULL;
Node<T> *temp2 = node;
while(temp2 != NULL){
temp1 = temp2;
if(d -> data < temp2 -> data){
temp2 = temp2 -> left;
}else if(d -> data > temp2 -> data){
temp2 = temp2 -> right;
}else{
cout << " can't insert the existed node !" << endl;
delete d;
return node;
}
}
if(temp1 == NULL){
node = d;
}else if(d -> data < temp1 -> data){
temp1 -> left = d;
}else{
temp1 -> right = d;
}
return node;
}
template<class T>
Node<T>* Splay<T>::remove(Node<T>* &node, T d){
Node<T> *temp;
//judge whether the node is root
if(node == NULL){
return node;
}
// judge whether there existed d
if(search(node, d) == NULL){
return NULL;
}
//splay the node to root
node = splay(node, d);
if(node -> left != NULL){
temp = splay(node -> left, d);
temp -> right = node -> right;
}else{
temp = node -> right;
}
delete node;
return temp;
}
template<class T>
void Splay<T>::destroy(Node<T>* &node){
if(node == NULL){
return;
}
if(node -> left != NULL){
destroy(node -> left);
}
if(node -> right != NULL){
destroy(node -> right);
}
delete node;
}
template<class T>
void Splay<T>::print(Node<T> *node, T d, int direction){
if(node != NULL){
if(direction == 0){
cout << setw(2) << node -> data << " is root " << endl;
}else{
cout << setw(2) << node -> data << " is " << setw(2) << d << " 's " << setw(12) << (direction == 1 ? " right child " : " left child ") << endl;
}
print(node -> left, node -> data, -1);
print(node -> right, node -> data, 1);
}
}
#endif
2、main.cpp
//main.cpp
#include<iostream>
#include"splay.h"
using namespace std;
int main()
{
Splay<int> *splay = new Splay<int>();
int arr[6] = {10, 50, 40, 30, 20, 60};
cout << "*********** insert **************" << endl;
for(int i = 0; i < 6; i++){
splay -> insert(arr[i]);
}
cout << "*********** print **************" << endl;
splay -> print();
cout << endl;
cout << "*********** preOrder **************" << endl;
splay -> preOrder();
cout << endl;
cout << "*********** inOrder **************" << endl;
splay -> inOrder();
cout << endl;
cout << "*********** postOrder **************" << endl;
splay -> postOrder();
cout << endl;
cout << " the maximum value in Splay is " << splay -> max() << endl;
cout << " the minimum value in Splay is " << splay -> min() << endl;
cout << "*********** insert **************" << endl;
splay -> insert(35);
splay -> inOrder();
cout << endl;
splay -> print();
cout << "*********** remove **************" << endl;
splay -> remove(50);
splay -> inOrder();
cout << endl;
splay -> print();
cout << "*********** destroy **************" << endl;
splay -> destroy();
cout << "done ." << endl;
return 0;
}
practice makes perfect !
参考博客:伸展树(二)之 C++的实现