[从头学数学] 第258节 Python实现数据结构：伸展树(splay tree)

剧情提要：
阿伟看到了一本比较有趣的书，是关于《计算几何》的，2008年由北清派出版。很好奇
它里面讲了些什么，就来看看啦。

正剧开始：

星历2016年09月07日 08:41:50, 银河系厄尔斯星球中华帝国江南行省。
[工程师阿伟]正在和[机器小伟]一起研究[计算几何]]。





#
###
# @usage splayTree（伸展树），具有根元素记忆及动态调整功能的二叉搜索树
# @author mw
# @date 2016年09月07日 星期三 08:37:17
# @param
# @return
#
###
class SplayTree(object):
class __SplayNode(object):
def __init__(self, key, left = None, right = None):
self.key=key
self.left=left
self.right=right

def __iter__(self):
if self.left != None:
for elem in self.left:
yield elem

if (self.key != None):
yield self.key

if self.right != None:
for elem in self.right:
yield elem

#迭代的是Node类型，用于删除结点
def iternodes(self):
if self.left != None:
for elem in self.left.iternodes():
yield elem

if self != None and self.key != None:
yield self

if self.right != None:
for elem in self.right.iternodes():
yield elem

def info(self):
s = 'Key='+str(self.key)+', '+\
'LChild='+str(self.left)+', '+\
'RChild='+str(self.right);
print(s);

def __str__(self):
return str(self.key);

def __repr__(self):
if self != None:
s_1 = str(self.key);
else:
s_1 = 'None';

if self.left != None:
s_2 = str(self.left.key);
else:
s_2 = 'None';

if self.right != None:
s_3 = str(self.right.key);
else:
s_3 = 'None';

return '__SplayNode('+s_1+', ' + s_2 +', ' + s_3 +')';

def __init__(self):
self.root=None
self.header = SplayTree.__SplayNode(None) #For splay()

#LL
def singleLeftRotate(self,node):
k1=node.left
node.left=k1.right
k1.right=node
return k1

#RR
def singleRightRotate(self,node):
k1=node.right
node.right=k1.left
k1.left=node
return k1

#RL
def doubleLeftRotate(self,node):
node.left=self.singleRightRotate(node.left)
return self.singleLeftRotate(node)

#LR
def doubleRightRotate(self,node):
node.right=self.singleLeftRotate(node.right)
return self.singleRightRotate(node)

#伸展运动
def splay(self, key):
l = r = self.header
t = self.root
if t is None:
return

self.header.left = self.header.right = None

while True:
if key < t.key:
if t.left == None:
break;
if key < t.left.key:
t = self.singleLeftRotate(t);
if t.left == None:
break;
r.left = t
r = t
t = t.left

elif key > t.key:
if t.right == None:
break;
if key > t.right.key:
t = self.singleRightRotate(t);
if t.right == None:
break;
l.right = t
l = t
t = t.right
else:
break;

l.right = t.left
r.left = t.right
t.left = self.header.right
t.right = self.header.left
self.root = t

#
#和splay操作捆绑的方法
#

#插入
def insert(self, key):
if (self.root == None):
self.root = SplayTree.__SplayNode(key)
return

self.splay(key)
if self.root.key == key:
# If the key is already there in the tree, don't do anything.
return

n = SplayTree.__SplayNode(key)
if key < self.root.key:
n.left = self.root.left
n.right = self.root
self.root.left = None
else:
n.right = self.root.right
n.left = self.root
self.root.right = None
self.root = n

def remove(self, key):
self.splay(key)
if self.root is None or key != self.root.key:
return None;

# Now delete the root.
if self.root.left== None:
self.root = self.root.right
else:
x = self.root.right
self.root = self.root.left
self.splay(key)
self.root.right = x

return key;

def findMin(self):
if self.root == None:
return None
x = self.root
while x.left != None:
x = x.left
self.splay(x.key)
return x.key

def findMax(self):
if self.root == None:
return None
x = self.root
while (x.right != None):
x = x.right
self.splay(x.key)
return x.key

def find(self, key):
if self.root == None:
return None
self.splay(key)
if self.root.key != key:
return None
return self.root.key

def isEmpty(self):
return self.root == None

#
#结构信息查询，不与splay操作捆绑
#

def getRoot(self):
return repr(self.root);

def info(self):
a = [];
for x in self:
a.append(x);

print(a);

def __iter__(self):
if self.root != None:
return self.root.__iter__()
else:
return [].__iter__()

def __contains__(self, val):
for x in self:
if (x == val):
return True;

return False;

def __len__(self):
a = [];
for x in self:
a.append(x);

return len(a);

#求结点高度
def height(self, node):
if (node == None):
return 0;
else:
m = self.height(node.left);
n = self.height(node.right);
return max(m, n)+1;

#传回结点的原始信息
def iternodes(self):
if self.root != None:
return self.root.iternodes()
else:
return [None];

#寻找节点路径
def findNodePath(self, root, node):
path = [];
if root == None or root.key == None:
path = [];
return path

while (root != node):
if node.key < root.key:
path.append(root);
root = root.left;
elif node.key >= root.key:
path.append(root);
root = root.right;
else:
break;

path.append(root);
return path;

#寻找父结点
def parent(self, root, node):
path = self.findNodePath(root, node);
if (len(path)>1):
return path[-2];
else:
return None;

#是否左孩子
def isLChild(self, parent, lChild):
if (parent.getLeft() != None and parent.getLeft() == lChild):
return True;

return False;

#是否右孩子
def isRChild(self, parent, rChild):
if (parent.getRight() != None and parent.getRight() == rChild):
return True;

return False;

#求某元素是在树的第几层
#约定根为0层
#这个计算和求结点的Height是不一样的
def level(self, elem):
if self.root != None:
node = self.root;
lev = 0;

while (node != None):
if elem < node.key:
node = node.left;
lev+=1;
elif elem > node.key:
node = node.right;
lev+=1;
else:
return lev;

return -1;

else:
return -1;

#

用例：
#
if __name__ == '__main__':
splay = SplayTree();

a = [20, 30, 40, 120, 13, 39, 38, 40, 18, 101];

for item in a:
splay.insert(item);
print(splay.getRoot());
print(splay.height(splay.root));

splay.info();
print(len(splay));

for node in splay.iternodes():
print(splay.findNodePath(splay.root, node), '\n');

'''
for item in reversed(a):
print('remove:', splay.remove(item));
splay.getRoot();
print(splay.height(splay.root));

'''

print(splay.findMax());
print(splay.getRoot());

>>>
__SplayNode(20, None, None)
1
__SplayNode(30, 20, None)
2
__SplayNode(40, 30, None)
3
__SplayNode(120, 40, None)
4
__SplayNode(13, None, 20)
4
__SplayNode(39, 30, 40)
4
__SplayNode(38, 30, 39)
4
__SplayNode(40, 39, 120)
6
__SplayNode(18, 13, 39)
4
__SplayNode(101, 39, 120)
5
[13, 18, 20, 30, 38, 39, 40, 101, 120]
9
[__SplayNode(101, 39, 120), __SplayNode(39, 18, 40), __SplayNode(18, 13, 30), __SplayNode(13, None, None)]

[__SplayNode(101, 39, 120), __SplayNode(39, 18, 40), __SplayNode(18, 13, 30)]

[__SplayNode(101, 39, 120), __SplayNode(39, 18, 40), __SplayNode(18, 13, 30), __SplayNode(30, 20, 38), __SplayNode(20, None, None)]

[__SplayNode(101, 39, 120), __SplayNode(39, 18, 40), __SplayNode(18, 13, 30), __SplayNode(30, 20, 38)]

[__SplayNode(101, 39, 120), __SplayNode(39, 18, 40), __SplayNode(18, 13, 30), __SplayNode(30, 20, 38), __SplayNode(38, None, None)]

[__SplayNode(101, 39, 120), __SplayNode(39, 18, 40)]

[__SplayNode(101, 39, 120), __SplayNode(39, 18, 40), __SplayNode(40, None, None)]

[__SplayNode(101, 39, 120)]

[__SplayNode(101, 39, 120), __SplayNode(120, None, None)]

120
__SplayNode(120, 101, None)

#