B树bugfix

Author: ssjssh

src/ssj/tree/BTree.py

@@ -14,17 +14,16 @@ def __init__(self, is_leaf, keys, childs=None, parent=None):
         self.keys = list(sorted(keys))
         self.is_leaf = is_leaf
         self.__size = len(self.keys)
-        if childs is None:
-            self.childs = [None for x in xrange(0, self.__size)]
-            self.childs.append(None)
+        if not self.is_leaf and childs is None:
+            self.childs = [None for x in xrange(0, self.__size + 1)]
         else:
             self.childs = childs
         self.parent = parent
 
     def __str__(self):
         return "".join(['Node(keys=', ",".join(map(lambda key: str(key), self.keys)),
-                        ',leaf' if self.is_leaf else ',not leaf',
-                        ',childs num=', str(len(self.childs)), ')\n'])
+                        ',Leaf' if self.is_leaf else ',Not Leaf',
+                        ',childs num=', '0' if self.is_leaf else str(len(self.childs)), ')\n'])
 
     def __len__(self):
         return self.__size
@@ -35,13 +34,16 @@ def append(self, key):
         """
         result = self.__size
         self.__size += 1
+
         for x in xrange(0, result):
             if self.keys[x] > key:
                 self.keys.insert(x, key)
-                self.childs.insert(x, None)
+                if not self.is_leaf:
+                    self.childs.insert(x, None)
                 return x
         self.keys.append(key)
-        self.childs.append(None)
+        if not self.is_leaf:
+            self.childs.append(None)
         return result
 
     def search_child(self, instance):
@@ -63,23 +65,26 @@ def __init__(self, load_factor=4, *vargs):
         """Constructor for BTree"""
         self.__root = None
         self.__load_factor = load_factor
-        self.__size = len(vargs)
+        self.__size = 0
         map(self.insert, vargs)
 
     def insert(self, key):
         """
-        节点插入的时候不需要再检测节点是不是满了，因为load_factor>=2，每次插入节点前调整都是使得节点关键字个数为load_factor-1。
-        而插入一个关键字之后节点关键字个数是2*load_factor-1或者load_factor
+        插入一个节点
         :param key:
         :return:
         """
         if self.__root is None:
             self.__root = Node(True, [key])
             return
+
         cur_node = self.__root
         while not cur_node.is_leaf:
             self.__split(cur_node)
+            # 这个地方cur_node并没有被改变，所以是可以继续搜索的。
             cur_node = cur_node.search_child(key)
+            print(key)
+
         left_node, right_node = self.__split(cur_node)
         if left_node is None or right_node is None:
             # 返回None表示叶节点没有满
@@ -90,27 +95,41 @@ def insert(self, key):
                 right_node.append(key)
             else:
                 left_node.append(key)
+        self.__size += 1
 
     def __split(self, node):
+        """
+        在节点满的时候分裂节点。要注意两个问题：
+        1，根节点分裂的时候需要重新设置根节点
+        2，叶节点是没有子节点的，一次要时刻判断
+        :param node:
+        :return:
+        """
         if self.full(node):
             parent_node = node.parent
             middle_key = node.keys[self.__load_factor - 1]
             if parent_node is None:
                 # 处理根节点
-                self.__root = Node(False, [])
-                parent_node = self.__root
+                parent_node = self.__root = Node(False, [])
+
             parent_middle_index = parent_node.append(middle_key)
-            left_node = Node(node.is_leaf, node.keys[:self.__load_factor - 1], node.childs[:self.__load_factor],
+            left_node = Node(node.is_leaf, node.keys[:self.__load_factor - 1],
+                             None if node.is_leaf else node.childs[:self.__load_factor],
                              parent_node)
-            # 注意设定分裂节点的子节点的父指针
-            for child in left_node.childs:
-                if child is not None:
-                    child.parent = left_node
-            right_node = Node(node.is_leaf, node.keys[self.__load_factor:], node.childs[self.__load_factor:],
+
+            right_node = Node(node.is_leaf, node.keys[self.__load_factor:],
+                              None if node.is_leaf else node.childs[self.__load_factor:],
                               parent_node)
-            for child in right_node.childs:
-                if child is not None:
-                    child.parent = right_node
+
+            # 注意设定分裂节点的子节点的父指针，因为如果node是叶节点，那么两个子节点肯定都是叶节点，反之同理
+            if not node.is_leaf:
+                for child in left_node.childs:
+                    if child is not None:
+                        child.parent = left_node
+                for child in right_node.childs:
+                    if child is not None:
+                        child.parent = right_node
+
             parent_node.childs[parent_middle_index] = left_node
             parent_node.childs[parent_middle_index + 1] = right_node
             self.__root.is_leaf = False
@@ -125,6 +144,12 @@ def full(self, node):
 
     @classmethod
     def __search(cls, root, instance):
+        """
+        搜索树中节点
+        :param root:
+        :param instance:
+        :return:
+        """
         cur_node = root
         while True:
             cur_len = len(cur_node)
@@ -139,12 +164,20 @@ def __search(cls, root, instance):
                 cur_node = cur_node.childs[x]
 
     def min(self):
+        """
+        取出树中最小值
+        :return:
+        """
         cur_node = self.__root
         while not cur_node.is_leaf:
             cur_node = cur_node.childs[0]
         return cur_node.keys[0]
 
     def max(self):
+        """
+        取出树中最大值
+        :return:
+        """
         cur_node = self.__root
         while not cur_node.is_leaf:
             cur_node = cur_node.childs[-1]
@@ -182,19 +215,19 @@ def midorder(self, f):
     def __str__(self):
         return "\n".join(self.midorder(lambda s: str(s)))
 
-    def test(self):
-        print "-" * 20
-        print self.__root
-        print self.__root.childs[0]
-        print self.__root.childs[1]
+    def processor(self, key):
+        pass
 
 
 def main():
-    btree = BTree(3, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'R', 'S', 'T', 'U',
-                  'V', 'X', 'Y', 'Z')
-    print btree
+    import random
+    test = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'R', 'S', 'T', 'U',
+            'V', 'X', 'Y', 'Z']
+    random.shuffle(test)
+    btree = BTree(3, *test)
     print btree.max()
     print btree.min()
+    btree.test()
 
 
 if __name__ == "__main__":