splay树的实现

伸展树（Splay Tree），也叫分裂树，是一种二叉排序树，它能在O(log n)内完成插入、查找和删除操作。它由Daniel Sleator和Robert Tarjan创造，后者对其进行了改进。它的优势在于不需要记录用于平衡树的冗余信息。在伸展树上的一般操作都基于伸展操作。

伸展树并没有AVL的平衡要求，任意节点的左右子树可以相差任意深度。

基本伸展树操作：
1、插入：
    当一个节点插入时，先插入，然后调整树（伸展操作），使得新插入的节点在根上。
2、查找：
    如果查找成功（找到），然后调整树（伸展操作），使得被查找的节点成为树的新根。
如果查找失败（没有），那么在查找遇到NULL之前的那个节点成为新的根。也就是，如果查找的节点在树中，那么，此时根上的节点就是距离这个节点最近的节点。
3、查找最大(find_max)最小(find_min)：
      查找之后执行伸展。
4、删除最大最小：
a)删除最小：
    首先执行查找最小的操作。
这时，要删除的节点就在根上。根据二叉查找树的特点，根没有左子节点。
使用根的右子结点作为新的根，删除旧的包含最小值的根。
b)删除最大：
首先执行查找最大的操作。
删除根，并把被删除的根的左子结点作为新的根。
5、删除：
        首先执行查找操作，查找完后要删除的节点成为树根，然后删除根，剩下两个子树L（左子树）和R（右子树）。使用find_max查找L的最大节点，此时，L的根没有右子树。使R成为L的根的右子树。

可以看到算法的核心就是伸展操作，也就是调整树使得目标节点成为树根。

下面是我的实现，其实比AVL树还是简单不少，因为限制条件少了

// splay-tree.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<vector>

#define KeyType int
#define MAX -1000000
#define MIN 1000000

class SplayTree
{
public:
	static struct TreeNode
	{
		KeyType ele;
		TreeNode*lnode, *rnode, *parent;
	};
private:
	TreeNode*root;
	void splay(TreeNode*node);
	TreeNode*find_minmax(const KeyType val);

public:
	SplayTree()
	{
		root = NULL;
	}
	bool insert(const KeyType val);
	bool erase(const KeyType val);
	TreeNode*find(const KeyType val);
	TreeNode*find_max();
	TreeNode*get_root()
	{
		return root;
	}
};
SplayTree::TreeNode*SplayTree::find_minmax(const KeyType val)
{
	std::vector<TreeNode*>aa;
	aa.push_back(root);
	TreeNode*minmax = NULL;
	int near = MIN;
	while (!aa.empty())//非递归先根遍历
	{
		TreeNode*node = aa.back();
		aa.pop_back();
		if (node->ele - val > 0 && node->ele - val < near)
		{
			minmax = node;
			near = node->ele - val;

		}
		if (node->rnode != NULL)
			aa.push_back(node->rnode);
		if (node->lnode != NULL)
			aa.push_back(node->lnode);
	}
	return minmax;

}
bool SplayTree::insert(const KeyType val)
{
	if (root == NULL)
	{
		root = new TreeNode;
		root->ele = val;
		root->lnode = root->rnode = root->parent = NULL;
		return true;
	}
	TreeNode*pos = find_minmax(val);
	if (pos == NULL)
	{
		TreeNode*nn = root;
		while (nn->rnode != NULL)
		{
			nn = nn->rnode;
		}
		TreeNode*node = new TreeNode;
		node->ele = val;
		node->lnode = node->rnode = NULL;
		nn->rnode = node;
		node->parent = nn;
		splay(node);
		return true;
	}
	if (pos->lnode == NULL)
	{
		TreeNode*node = new TreeNode;
		node->ele = val;
		node->lnode = node->rnode = NULL;
		pos->lnode = node;
		node->parent = pos;
		splay(node);
		return true;
	}
	TreeNode*nn = pos->lnode;
	while (nn->rnode != NULL)
	{
		nn = nn->rnode;
	}
	TreeNode*node = new TreeNode;
	node->ele = val;
	node->lnode = node->rnode = NULL;
	nn->rnode = node;
	node->parent = nn;
	splay(node);
	return true;
}

bool SplayTree::erase(const KeyType val)
{
	if (root == NULL)
		return false;
	TreeNode*todel = find(val);
	if (todel->ele != val)
		return false;
	TreeNode*r_node = root->rnode;
	TreeNode*l_node = root->lnode;
	delete root;
	if (l_node == NULL)
	{
		root = r_node;
		if (r_node != NULL)
			root->parent = NULL;
		return true;
	}
	root = l_node;
	root->parent = NULL;
	find_max();
	root->rnode = r_node;
	if (r_node != NULL)
		r_node->parent = root;
	return true;
}
SplayTree::TreeNode* SplayTree::find_max()
{
	if (root == NULL)
		return false;
	TreeNode*node = root;
	while (node->rnode != NULL)
	{
		node = node->rnode;
	}
	splay(node);
	return root;
}

SplayTree::TreeNode* SplayTree::find(const KeyType val)
{
	if (root == NULL)
		return NULL;
	TreeNode*node = root;
	TreeNode*nn = NULL;
	while (node != NULL)
	{
		if (node->ele == val)
		{
			splay(node);
			return root;
		}
		if (node->ele > val)
		{
			nn = node;
			node = node->lnode;
		}
		else
		{
			nn = node;
			node = node->rnode;
		}
	}
	_ASSERTE(nn != NULL);
	splay(nn);
	return root;
}
void SplayTree::splay(SplayTree::TreeNode*node)
{
	while (node->parent != NULL)
	{
		if (node->parent == root)
		{
			if (root->lnode == node)
			{
				TreeNode*nn = node;
				while (nn->rnode != NULL)
				{
					nn = nn->rnode;
				}
				root->lnode = NULL;
				nn->rnode = root;
				root->parent = nn;
				node->parent = NULL;
				root = node;
				return;
			}
			if (root->rnode == node)
			{
				TreeNode*nn = node;
				while (nn->lnode != NULL)
				{
					nn = nn->lnode;
				}
				root->rnode = NULL;
				nn->lnode = root;
				root->parent = nn;
				node->parent = NULL;
				root = node;
				return;
			}
		}
		TreeNode*parent = node->parent;
		TreeNode*grandpa = node->parent->parent;
		if (parent->rnode == node&&grandpa->lnode == parent)
		{

			TreeNode*node_lnode = node->lnode;
			TreeNode*node_rnode = node->rnode;
			TreeNode*gg = grandpa->parent;
			bool isleft = true;
			if (gg != NULL&&gg->rnode == grandpa)
				isleft = false;
			node->lnode = parent;
			node->rnode = grandpa;
			parent->parent = node;
			grandpa->parent = node;
			parent->rnode = node_lnode;
			if (node_lnode != NULL)
				node_lnode->parent = parent;
			grandpa->lnode = node_rnode;
			if (node_rnode != NULL)
				node_rnode->parent = grandpa;
			if (gg == NULL)
			{
				node->parent = NULL;
				root = node;
				return;
			}
			node->parent = gg;

			if (isleft)
				gg->lnode = node;
			else
				gg->rnode = node;

		}
		else if (parent->lnode == node&&grandpa->rnode == parent)
		{
			TreeNode*node_lnode = node->lnode;
			TreeNode*node_rnode = node->rnode;
			TreeNode*gg = grandpa->parent;
			bool isleft = true;
			if (gg != NULL&&gg->rnode == grandpa)
				isleft = false;
			node->rnode = parent;
			node->lnode = grandpa;
			parent->parent = node;
			grandpa->parent = node;
			parent->lnode = node_rnode;
			if (node_rnode != NULL)
				node_rnode->parent = parent;
			grandpa->rnode = node_lnode;
			if (node_lnode != NULL)
				node_lnode->parent = grandpa;
			if (gg == NULL)
			{
				node->parent = NULL;
				root = node;
				return;
			}
			node->parent = gg;

			if (isleft)
				gg->lnode = node;
			else
				gg->rnode = node;
		}
		else if (parent->rnode == node&&grandpa->rnode == parent)
		{
			TreeNode*node_lnode = node->lnode;
			TreeNode*parent_lnode = parent->lnode;
			TreeNode*gg = grandpa->parent;
			bool isleft = true;
			if (gg != NULL&&gg->rnode == grandpa)
				isleft = false;
			node->lnode = parent;
			parent->lnode = grandpa;
			parent->parent = node;
			grandpa->parent = parent;
			parent->rnode = node_lnode;
			if (node_lnode != NULL)
				node_lnode->parent = parent;
			grandpa->rnode = parent_lnode;
			if (parent_lnode != NULL)
				parent_lnode->parent = grandpa;
			if (gg == NULL)
			{
				node->parent = NULL;
				root = node;
				return;
			}
			node->parent = gg;
			if (isleft)
				gg->lnode = node;
			else
				gg->rnode = node;
		}
		else if (parent->lnode == node&&grandpa->lnode == parent)
		{
			TreeNode*node_rnode = node->rnode;
			TreeNode*parent_rnode = parent->rnode;
			TreeNode*gg = grandpa->parent;
			bool isleft = true;
			if (gg != NULL&&gg->rnode == grandpa)
				isleft = false;
			node->rnode = parent;
			parent->rnode = grandpa;
			parent->parent = node;
			grandpa->parent = parent;
			parent->lnode = node_rnode;
			if (node_rnode != NULL)
				node_rnode->parent = parent;
			grandpa->lnode = parent_rnode;
			if (parent_rnode != NULL)
				parent_rnode->parent = grandpa;
			if (gg == NULL)
			{
				node->parent = NULL;
				root = node;
				return;
			}
			node->parent = gg;
			if (isleft)
				gg->lnode = node;
			else
				gg->rnode = node;
		}
		else
			_ASSERTE(1 < 0);
	}
}
int _tmain(int argc, _TCHAR* argv[])
{
	SplayTree st;
	st.insert(100);
	SplayTree::TreeNode*root = st.get_root();
	st.insert(500);
	root = st.get_root();
	st.insert(600);
	root = st.get_root();
	st.insert(800);
	root = st.get_root();
	st.insert(1000);
	root = st.get_root();
	st.insert(1500);
	root = st.get_root();
	st.insert(900);
	root = st.get_root();
	st.insert(300);
	root = st.get_root();
	st.insert(200);
	root = st.get_root();
	st.insert(700);
	root = st.get_root();
	st.insert(550);
	root = st.get_root();
	st.insert(350);
	root = st.get_root();
	st.insert(650);
	root = st.get_root();
	st.insert(750);
	root = st.get_root();
	st.insert(950);
	root = st.get_root();
	st.insert(400);
	root = st.get_root();
	st.insert(450);
	root = st.get_root();
	st.insert(250);
	root = st.get_root();
	st.insert(580);
	root = st.get_root();
	st.insert(380);
	root = st.get_root();
	st.insert(660);
	root = st.get_root();
	st.insert(780);
	root = st.get_root();
	st.find(750);
	root = st.get_root();
	st.erase(780);
	root = st.get_root();
	return 0;
}

版权声明：