引言
在前面的文章《B+树插入操作的图形化展示,python调用graphviz自动生成svg图形》中用图形化的方式展示了B+树在插入时图形的变化。
本文尝试将B+树数据保存到硬盘,并且可以根据需要随时加载到内存。前面做的图形化工作,正好可以用来直观地验证从文件加载B+树是否成功。
网上文献《关于 B+tree (附 python 模拟代码)》的作者用python实现了B+树的基本操作。但是他的输出结果是文本形式的,不方便直观地查看B+树的动态变化效果。本文在原作者python代码的基础上做了一些改进,实现了图形化展示的效果,添加了序列化为json格式文件的功能。对原作者的分享精神,再次表示感谢。
具体实现
下面是实现的效果图
这是序列化后的根节点#8号节点的内容
{"c": [4, 11, 7], "i": [17, 33], "M": 4, "par": 0, "bro": -1, "id": 8}
可以看出,json数据与图中数据是完全对应的,#8节点的id为8,孩子列表为[4, 11, 7],索引列表为[17, 33]
这是序列化后内部#4号节点的内容
{"c": [2, 10], "i": [9], "M": 4, "par": 8, "bro": -1, "id": 4}
这是序列化后叶子节点 #2号节点的内容
{"bro": 10, "par": 4, "id": 2, "L": 4, "v": ["2,e", "4,m", "6,c"]}
序列化中的关键技术点
1 .选用json格式保持节点数据,因为json格式容易理解,并且方便数据交换,而pickle格式只能在python中进行数据交换。
2.节点指针的序列化,为每个节点赋一个唯一性的整数,做为其id,在序列化节点指针时实际保存的是被指向的节点的id
下面是节点序列化的具体转换函数,节点分为内部节点与叶子节点
#内部节点转换为字典类型
def interNode2Dict(n):
return {
'M':n.M,
'c':[i.id for i in n.childList],
'i':[i for i in n.indexList],
'bro':-1, #内部节点不需要brother指针,用-1表明这是一个内部节点
'par':n._par.id if n._par else 0,
'id':n.id
}
#叶子节点转换为字典类型
def leafNode2Dict(n):
return {
'L':n.L ,
'v':[str(i) for i in n.valueList],
'bro':n._bro.id if n._bro else 0,
'par':n._par.id if n._par else 0,
'id':n.id
}
在上述代码中,留意这一句
'c':[i.id for i in n.childList],
这就实现了将孩子对象指针转换成了孩子对象的id。
要注意这一个转换是有特别的考虑的,如果不做这个转换,而直接使用对象引用(指针),json在做序列化时会循着这个引用(指针)把整个对象链上的其它的对象也一并序列化。这样一来,要么是序列化出一堆不想要的东西;要么是发生循环引用;要么是发现某些对象不能json化。用整数id来代替指针就把这些问题都化解了。
3.为了保证节点可以json序列化,用json自带的常规类型的序列化功能不不够,还要自定义特别的转换类
class NodeEncoder(json.JSONEncoder):
def default(self, n):
if isinstance(n, Bptree_InterNode):
return interNode2Dict(n)
if isinstance(n, Bptree_Leaf):
return leafNode2Dict(n)
return json.JSONEncoder.default(self, n)
在做序列化时的调用格式如下:
json.dumps(n,cls=NodeEncoder)
与常规对象的序列化相比,多给了一个参数 cls=NodeEncoder,而这里的NodeEncoder就是刚才定义的转换类
4.每个节点保存为一个单独的json格式的文件,文件名的命令格式为 node+id+".json"
比如上文提到的根节点#8号节点的内容就保存为文件:node8.json。这样做的好处时,只要给出节点的id,就可以方便地找出节点被序列化后的内容。
5.在反序列化时实现按需加载,在B+树反序列化时,其实一开始只反序列化了根节点,只有当实际访问某个子节点时,子节点才被加载到内存。实现原理如以下代码所示
if type(self._childList[i])==type(0): #需要加载
self._childList[i] = loadNode(self._childList[i])
return self._childList[i]
刚从json串反序列化后,_childList[i]中存放的其实是一个整数id值,当实际访问这个孩子对象时,才由loadNode函数进行加载。这是一种典型的懒加载策略。loadNode函数的核心代码如下:
if str(id) in nodePool :
return nodePool[str(id)]
rawNode=None
with open('nodes/node'+str(id)+'.json', 'r') as f:
rawNode = json.load(f)
#debug(rawNode)
if rawNode :
if rawNode['bro'] < 0 :#加载内部节点
n=Bptree_InterNode(rawNode['M'],rawNode['id'])
n._bro=-1
n._par= rawNode['par']
n.childList= ChildList(rawNode['c'])
#debug(n.childList._childList,'childList._childList')
n.indexList= rawNode['i']
nodePool[str(id)]=n
else:#加载叶子节点
n=Bptree_Leaf(rawNode['L'],rawNode['id'])
n._bro= rawNode['bro']
n._par= rawNode['par']
n.valueList= [loadKV(s) for s in rawNode['v']]
nodePool[str(id)]=n
return n
这里用到了一个节点池,如果节点已经加载过了,就不会重复加载,如果是第一次加载,就要从json文件中读取。
6.为了实现按需加载,不用普通的列表来保存孩子节点的指针,而用是特定化的类对象,看一下这个类对象的代码
class ChildList(object):
def __init__(self,listVal=[]):
self._childList = listVal
def __getitem__(self,i):
if type(self._childList[i])==type(0): #需要加载
self._childList[i] = loadNode(self._childList[i])
return self._childList[i]
def __setitem__(self,i,value):
self._childList[i] = value
def index(self,value):
return self._childList.index(value)
def insert(self,i,value):
return self._childList.insert(i,value)
特别留意一下其中的方法:getitem(self,i)
def __getitem__(self,i):
if type(self._childList[i])==type(0): #需要加载
self._childList[i] = loadNode(self._childList[i])
return self._childList[i]
实现了这个方法之后,这个类的对象就可以象数组一样进行访问,比如n.childList是ChildList类的一个对象,就可以这样来访问
n.childList[0]。这样看起来childList仿佛还是一个普通的列表。但与普通列表不同的是,在它的方法体中有这样一句
if type(self._childList[i])==type(0): #需要加载
self._childList[i] = loadNode(self._childList[i])
当发现内部列表(数组)的一项存放的是整数,调用了加载函数从json文件加载对象。而这一点,是普通的列表对象做不到的。所以在这里要做特别的处理。
7 其它节点对象的指针(引用)属性,采用@property修饰的方法,也是为了在访问时可以按需加载,比如节点的父指针。另外还使用了@par.setter,这样可以在父指针被修改时做一些额外的处理,比如标记节点“脏”了。
@property
def par(self):
if type(self._par)==type(0): #需要加载
self._par = loadNode(self._par)
return self._par
@par.setter
def par(self,value):
#可在此处做一些额外的处理
self._par=value
8 用一个固定的文件node1.json存放B+树根节点的id。因为在B+树的动态变化时,其根节点很可能会因为分裂或合并而发生变化,但不管如何变化,node1.json中总是存放实际的B+树根节点的id。这样在反序列化时总有一个固定的入口点node1.js
完整的python代码
# -*- coding:utf-8 -*-
# B+树的序列化
# 原作者:thursdayhawk http://wiki.jikexueyuan.com/project/python-actual-combat/tutorial-11.html
# 修改成用graphviz图形化显示,添加了序列化为json格式文件的功能,修改者:littleZhuHui
import os
import json
from random import randint,choice
from bisect import bisect_right,bisect_left
from collections import deque
#显示信息的级别,控制不同等级的信息的可见性
infoLevel = 3
# id值为1的节点是 superRoot,是所有操作的起点,
#因此固定为1,而0表示找不到有效的节点
idSeed = 1
#存放已加载节点的hash表,由节点id映射到节点对象
nodePool ={}
#生成一个全局ID
def getGID():
global idSeed
idSeed+=1
return idSeed
节
#------------------ node 定义开始 ----------------------------------------------
class InitError(Exception):
pass
class LoadNodeError(Exception):
pass
class ParaError(Exception):
pass
# 定义键值对
class KeyValue(object):
__slots__=('key','value')
def __init__(self,key,value):
self.key=key
self.value=value
def __str__(self):
return '%s,%s'%(self.key,self.value)
def __cmp__(self,key):
if self.key>key:
return 1
elif self.key==key:
return 0
else:
return -1
# 定义可按下标进行控制访问的childList类
# 不直接使用列表而用自定义对象表示childList ,主要原因有两点
# 按需加载,孩子节点序列化时存放的节点Id值,当实际访问时加载为对象
# 访问控制,当修改了孩子节点指针的值之后,可以有机会做更多的处理(可以实现事件钩子功能)
class ChildList(object):
def __init__(self,listVal=[]):
self._childList = listVal
def __getitem__(self,i):
if type(self._childList[i])==type(0): #需要加载
self._childList[i] = loadNode(self._childList[i])
return self._childList[i]
def __setitem__(self,i,value):
self._childList[i] = value
def index(self,value):
return self._childList.index(value)
def insert(self,i,value):
return self._childList.insert(i,value)
# 内部节点
class Bptree_InterNode(object):
def __init__(self,M,id=-1):
if not isinstance(M,int):
raise InitError,'M must be int'
if M<=3:
raise InitError,'M must be greater then 3'
else:
self.M=M
self.childList=ChildList()
self.indexList=[]
self._bro=-1
self._par=None
#每个节点有一个唯一的整数值做为id,方便用graphviz绘图
if id < 0:
self.id = getGID()
else:
self.id = id
def isleaf(self):
return False
def isfull(self):
return len(self.indexList)>=self.M-1
def isempty(self):
return len(self.indexList)<=(self.M+1)/2-1
@property
def bro(self):
if type(self._bro)==type(0): #需要加载
self._bro = loadNode(self._bro)
return self._bro
@bro.setter
def bro(self,value):
#可在此处做一些额外的处理
self._bro=value
@property
def par(self):
if type(self._par)==type(0): #需要加载
self._par = loadNode(self._par)
return self._par
@par.setter
def par(self,value):
#可在此处做一些额外的处理
self._par=value
#叶子节点
class Bptree_Leaf(object):
def __init__(self,L,id=-1):
if not isinstance(L,int):
raise InitError,'L must be int'
else:
self.L=L
self.childList='<br>\nleaf has no child list<br>\n'
self.valueList=[]
self._bro=0
self._par=None
#每个节点有一个唯一的整数值做为id,方便用graphviz绘图
if id < 0:
self.id = getGID()
else:
self.id = id
def isleaf(self):
return True
def isfull(self):
return len(self.valueList)>self.L
def isempty(self):
return len(self.valueList)<=(self.L+1)/2
@property
def bro(self):
if type(self._bro)==type(0): #需要加载
self._bro = loadNode(self._bro)
return self._bro
@bro.setter
def bro(self,value):
#可在此处做一些额外的处理
self._bro=value
@property
def par(self):
if type(self._par)==type(0): #需要加载
self._par = loadNode(self._par)
return self._par
@par.setter
def par(self,value):
#可在此处做一些额外的处理
self._par=value
#------------------ node 定义结束 ----------------------------------------------
#------------------ B+ 树 定义开始 ----------------------------------------
#B+树类
class Bptree(object):
def __init__(self,M,L):
if L>M:
raise InitError,'L must be less or equal then M'
else:
self.M=M
self.L=L
self.__root=Bptree_Leaf(L)
self.__leaf=self.__root
#在树上查找
def search(self,mi=None,ma=None):
result=[]
node=self.__root
leaf=self.__leaf
if mi is None and ma is None:
raise ParaError,'you need to setup searching range'
elif mi is not None and ma is not None and mi>ma:
raise ParaError,'upper bound must be greater or equal than lower bound'
def search_key(n,k):
if n.isleaf():
p=bisect_left(n.valueList,k)
return (p,n)
else:
p=bisect_right(n.indexList,k)
return search_key(n.childList[p],k)
if mi is None:
while True:
for kv in leaf.valueList:
if kv<=ma:
result.append(kv)
else:
return result
if leaf.bro==None:
return result
else:
leaf=leaf.bro
elif ma is None:
index,leaf=search_key(node,mi)
result.extend(leaf.valueList[index:])
while True:
if leaf.bro==None:
return result
else:
leaf=leaf.bro
result.extend(leaf.valueList)
else:
if mi==ma:
i,l=search_key(node,mi)
try:
if l.valueList[i]==mi:
result.append(l.valueList[i])
return result
else:
return result
except IndexError:
return result
else:
i1,l1=search_key(node,mi)
i2,l2=search_key(node,ma)
if l1 is l2:
if i1==i2:
return result
else:
result.extend(l.valueList[i1:i2])
return result
else:
result.extend(l1.valueList[i1:])
l=l1
while True:
if l.bro==l2:
result.extend(l2.valueList[:i2+1])
return result
else:
result.extend(l.bro.valueList)
l=l.bro
#遍历B+树的所有叶子节点
def traversal(self):
result=[]
l=self.__leaf
while True:
result.extend(l.valueList)
if l.bro==None:
return result
else:
l=l.bro
#显示B+树
def show(self):
def dotShow(tree):
q=deque()
h=0
q.append([self.__root,h])
#生成childList对应的dot格式的文本串
def childListDotStr(n):
dotStr ='{'
if n.childList==[]:
return '{}'
else:
for i,k in enumerate(n.indexList):
dotStr +='<f%s>#%s|'%(n.childList[i].id,n.childList[i].id)
#childList比indexList多一个,要处理一下最右孩子指针
dotStr +='<f%s>#%s}'%(n.childList[-1].id,n.childList[-1].id)
return dotStr
#生成childList对应的dot格式的文本串
def childListEdgeStr(n):
dotStr =''
if n.childList==[]:
return ''
else:
for i,k in enumerate(n.indexList):
dotStr +='node%s:f%s:s--node%s:e:n;\n'% (n.id,n.childList[i].id,n.childList[i].id)
#childList比indexList多一个,要处理一下最右孩子指针
dotStr +='node%s:f%s:s--node%s:e:n;\n'% (n.id,n.childList[-1].id,n.childList[-1].id)
return dotStr
while True:
try:
node,height=q.popleft()
except IndexError:
return
else:
if not node.isleaf(): #内部节点
#print node.indexList,'the height is',height
nodeText = str([k for k in node.indexList])
tree.dotStr += 'node%s [label = "{<e> #%s|%s| %s}" ];\n'% (node.id,node.id,nodeText,childListDotStr(node))
tree.dotStr += childListEdgeStr(node)
if height==h:
h+=1
q.extend([[n,h] for n in node.childList])
else: #叶节点
#print [v.key for v in node.valueList],'the leaf is,',height
nodeText = str([k.key for k in node.valueList])
tree.dotStr += 'node%s [label = "{<e> #%s|%s}" ];\n'% (node.id,node.id,nodeText)
self.dotStr=''
dotShow(self)
print(self.svgStr())
#导出B+树
def dump(self):
def doDump():
q=deque()
h=0
q.append([self.__root,h])
while True:
try:
node,height=q.popleft()
dumpNode(node)
except IndexError:
return
else:
if not node.isleaf(): #内部节点
if height==h:
h+=1
q.extend([[n,h] for n in node.childList])
else: #叶节点
pass
doDump()
#保存根节点的id信息到node1.json
with open('nodes/node1.json', 'w') as f:
f.write(json.dumps({'id':self.__root.id}))
#加载根节点,而子节点是在真实访问时,发现如果存放的是整数id值,才真正加载进来(按需加载)
def loadRoot(self,nodeId):
self.__root = loadNode(nodeId)
self.__leaf=self.__root
#debug(self.__root,'__root')
#加载B+树,假定根节点信息总是存话在node1.json文件中
def load(self):
rawNode=None
with open('nodes/node1.json', 'r') as f:
rawNode = json.load(f)
#debug(rawNode)
if rawNode :
nodeId = rawNode['id']
self.loadRoot(nodeId)
else:
raise LoadNodeError,'can not load node1.json '
# 生成svg图形对应的文本串
def svgStr(self):
dotHeader ='''
graph G
{
rankdir = TB;
node [shape=record];
'''
dotStr = dotHeader + self.dotStr +'}'
dotFile =open('BplusTree.dot','w')
dotFile.write(dotStr)
dotFile.close()
#调用dot命令生成svg文件
os.system('dot -Tsvg BplusTree.dot -o BplusTree.html')
#取出svg图形文件的内容
svgFile =open('BplusTree.html','r')
svgStr = svgFile.read()
svgFile.close()
return svgStr
#插入操作
def insert(self,key_value):
def split_node(n1):
mid=self.M/2 #分裂点为度数的中点
newnode=Bptree_InterNode(self.M)
#新节点的数据是原节点的后半部分
newnode.indexList=n1.indexList[mid:]
newnode.childList=ChildList(n1.childList[mid:])
newnode.par=n1.par
for c in newnode.childList:
c.par=newnode
if n1.par is None: #如果当前节点是根节点,则创建一个新的根节点
newroot=Bptree_InterNode(self.M)
tipInfo(' #%s 号内部节点分裂,键 %s 将复制(上升)到新的根节点 #%s 中'%(n1.id,n1.indexList[mid-1],newroot.id))
newroot.indexList=[n1.indexList[mid-1]]
newroot.childList=ChildList([n1,newnode])
n1.par=newnode.par=newroot
self.__root=newroot
else: #如果当前节点不是根节点
tipInfo(' #%s 号内部节点分裂,键 %s 将复制(上升)到父节点 #%s 中'%(n1.id,n1.indexList[mid-1],n1.par.id))
i=n1.par.childList.index(n1)
n1.par.indexList.insert(i,n1.indexList[mid-1])
n1.par.childList.insert(i+1,newnode)
n1.indexList=n1.indexList[:mid-1]
n1.childList=ChildList(n1.childList[:mid])
return n1.par
#叶子节点分裂
def split_leaf(n2):
mid=(self.L+1)/2 #分裂点为叶子节点度数+1的中点
newleaf=Bptree_Leaf(self.L)
newleaf.valueList=n2.valueList[mid:]
if n2.par==None: #如果当前节点是既是叶子节点又是根节点,则创建一个新的内部节点
newroot=Bptree_InterNode(self.M)
tipInfo(' #%s 号叶子节点分裂,键 %s 将复制(上升)到新的根节点 #%s 中'%(n2.id,n2.valueList[mid].key,newroot.id))
newroot.indexList=[n2.valueList[mid].key]
newroot.childList=ChildList([n2,newleaf])
n2.par=newroot
newleaf.par=newroot
self.__root=newroot
else:
tipInfo(' #%s 号叶子节点分裂,键 %s 将复制(上升)到父节点 #%s 中'%(n2.id,n2.valueList[mid].key,n2.par.id))
i=n2.par.childList.index(n2)
n2.par.indexList.insert(i,n2.valueList[mid].key)
n2.par.childList.insert(i+1,newleaf)
newleaf.par=n2.par
n2.valueList=n2.valueList[:mid]
n2.bro=newleaf
#插入节点
def insert_node(n):
tipInfo('对 #%s 号节点进行检查 '%(n.id))
if not n.isleaf():
tipInfo(' #%s 号节点是内部节点 '%(n.id))
if n.isfull():
tipInfo(' #%s 号节点已满,分裂后再做插入操作 '%(n.id))
insert_node(split_node(n))
else:
p=bisect_right(n.indexList,key_value)
#tipInfo(' 插入位置:%s '%p)
pp = 0 if p == 0 else p - 1
if p > 0:
tipInfo(' #%s 号节点未满,找到稍小于 %s 的键值 %s ,在 %s 的右孩子 #%s 号节点上执行插入操作'%(n.id,key_value.key,n.indexList[pp],n.indexList[pp],n.childList[p].id))
else:
tipInfo(' #%s 号节点未满,只能找到比 %s 稍大的键值 %s ,在 %s 的左孩子 #%s 号节点上执行插入操作'%(n.id,key_value.key,n.indexList[pp],n.indexList[pp],n.childList[p].id))
insert_node(n.childList[p])
else:
tipInfo(' #%s 号节点是叶子节点, 实际插入键值与卫星数据 '%(n.id))
p=bisect_right(n.valueList,key_value)
n.valueList.insert(p,key_value)
if n.isfull():
tipInfo(' #%s 号叶子节点已满, 分裂该节点 '%(n.id))
split_leaf(n)
else:
return
insert_node(self.__root)
#------------------ B+ 树 定义结束 ----------------------------------------
#------------------ 序列化相关函数 开始 ----------------------------------------
#加载kv
def loadKV(str):
#debug(str,'loadKV')
t=str.split(',')
k=int(t[0])
v=t[1]
return KeyValue(k,v)
#加载节点
def loadNode(id):
global nodePool
if str(id) in nodePool :
return nodePool[str(id)]
rawNode=None
with open('nodes/node'+str(id)+'.json', 'r') as f:
rawNode = json.load(f)
#debug(rawNode)
if rawNode :
if rawNode['bro'] < 0 :#加载内部节点
n=Bptree_InterNode(rawNode['M'],rawNode['id'])
n._bro=-1
n._par= rawNode['par']
n.childList= ChildList(rawNode['c'])
#debug(n.childList._childList,'childList._childList')
n.indexList= rawNode['i']
nodePool[str(id)]=n
else:#加载叶子节点
n=Bptree_Leaf(rawNode['L'],rawNode['id'])
n._bro= rawNode['bro']
n._par= rawNode['par']
n.valueList= [loadKV(s) for s in rawNode['v']]
nodePool[str(id)]=n
return n
else:
raise LoadNodeError,'can not load node :%s'%id
#导出节点
def dumpNode(n):
with open('nodes/node'+str(n.id)+'.json', 'w') as f:
f.write(json.dumps(n,cls=NodeEncoder))
#节点编码为可以json化的类型时需要用到的转换类
class NodeEncoder(json.JSONEncoder):
def default(self, n):
if isinstance(n, Bptree_InterNode):
return interNode2Dict(n)
if isinstance(n, Bptree_Leaf):
return leafNode2Dict(n)
return json.JSONEncoder.default(self, n)
#内部节点转换为字典类型
def interNode2Dict(n):
return {
'M':n.M,
'c':[i.id for i in n.childList],
'i':[i for i in n.indexList],
'bro':-1, #内部节点不需要brother指针,用-1表明这是一个内部节点
'par':n._par.id if n._par else 0,
'id':n.id
}
#叶子节点转换为字典类型
def leafNode2Dict(n):
return {
'L':n.L ,
'v':[str(i) for i in n.valueList],
'bro':n._bro.id if n._bro else 0,
'par':n._par.id if n._par else 0,
'id':n.id
}
#------------------ 序列化相关函数 结束 ----------------------------------------
def tipInfo(str):
global infoLevel
if infoLevel and infoLevel < 2:
println(str)
def debug(value,tip=''):
global infoLevel
if infoLevel and infoLevel < 1:
print('\n<br>****** debug ****** %s *******'%tip)
print(value)
print('\n<br>')
def println(str):
print('\n<br>')
print(str)
print('\n<br>')
#固定序列
def fixTestList():
testlist=[]
keyList =[10, 17, 9, 33, 33, 50, 36, 41, 31, 30, 13, 6, 37, 45, 20, 4, 35, 11, 2, 40]
#通常情况下树高为3,下面这个序列会生成树高为4的B+树,可以分析一下为什么会这样?
#keyList =[3, 33, 25, 30, 15, 27, 16, 35, 28, 39, 44, 2, 47, 45, 14, 42, 18, 3, 9, 18, 34, 19, 33, 46, 24, 45, 48, 20, 10, 8, 35, 3, 49, 48, 50, 9, 46, 1, 31, 6, 37, 34, 33, 37, 6, 48, 39, 24, 17]
for key in keyList:
value=choice('abcdefghijklmn')
testlist.append(KeyValue(key,value))
tipInfo(str([k.key for k in testlist]))
return testlist;
#随机序列,用50个数的随机序列生成B+树时,观察生成的图形,大部分时候树高都是3,
#但偶尔出现树高为4,是因为B+树在面对特定数据时树高会高一些吗?
def randTestList():
testlist=[]
for i in range(1,100):
key=randint(1,100)
value=choice('abcdefghijklmn')
testlist.append(KeyValue(key,value))
tipInfo(str([k.key for k in testlist]))
return testlist;
#测试插入操作
def testInsert():
M=4
L=4
#构造一个空的B+树
mybptree=Bptree(M,L)
println('B+树的插入过程, 内部%s阶,叶子%s阶 '%(M,L))
tipInfo('插入序列')
testlist = fixTestList()
#testlist = randTestList()
for kv in testlist:
tipInfo('<br>------------ 准备插入 %s : -------------------------------'%kv.key)
mybptree.insert(kv)
tipInfo('插入 %s 后的B+树'%kv.key)
mybptree.show()
#导出B+树
mybptree.dump()
#测试加载操作
def testLoad():
M=4
L=4
# M=6
# L=6
#构造一个空的B+树
mybptree=Bptree(M,L)
println('插入B+树, 内部%s阶,叶子%s阶 '%(M,L))
tipInfo('插入序列')
testlist = fixTestList()
#testlist = randTestList()
for kv in testlist:
mybptree.insert(kv)
mybptree.show()
#导出B+树
mybptree.dump()
println('<br>加载B+树, 内部%s阶,叶子%s阶 '%(M,L))
mybptree.load()
mybptree.show()
if __name__=='__main__':
#testInsert()
testLoad()
补充说明
图形化显示环境的搭建细节,还请参看以前的文章《平衡二叉树插入及删除操作的图形化展示,python调用graphviz自动生成svg图形》
对svg图形做美化处理的细节,还请参看以前的文章《用jquery对graphviz生成的svg图形做后处理,改变字体,颜色,连线形状等》