ajout des test, a modifier + avancé sur split et insertion

src/BTree.py

-import Node as Bnode
+#import Node as Bnode
+from node import *
 
 
 class Btree() :
@@ -11,18 +12,35 @@ class Btree() :
         return self.root.search(value)
 
 # incomplet
-    def insertion(self, value):
-        if (self.root == None):
-            self.root = Bnode.Node(self.k)
-            self.root.keys[0] = value
-        else :
-            if ( len(self.root) ==  self.k):
-                new_root = Bnode.Node(self.k)
-                new_root.childs[0] = self.root
-                
-                if (self)
-            else:
-                self.root.insert_not_full(value)
+#     def insertion(self, value):
+#         
+#         if (self.root == None):
+#             self.root = Bnode.Node(self.k)
+#             self.root.keys[0] = value
+#         else :
+#             if ( len(self.root) ==  self.k):
+#                 new_root = Bnode.Node(self.k)
+#                 new_root.childs[0] = self.root
+#                 
+#                 if (self) :
+#                     ##TODO
+#                     return None
+#             else:
+#                 self.root.insert_not_full(value)
+#
+
+    def insertion(self,value):
+        """
+        >>> Node([5,25]).insertion(10)
+        Node([5,10,25])
+        >>> Node([]).insertion(1)
+        Node([1])
+        >>> Node([5,25]).insertion(50)
+        Node([5,25,50])
+        """
+        
+        
+        
             
         
         
@@ -40,4 +58,9 @@ class Btree() :
     #def getNbKeys () :
     #def getSize () :
     #def changeRoot() :
-    #def isEqual() :
+    #def isEqual() :
\ No newline at end of file
+                
+                
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod(verbose=True)
\ No newline at end of file

src/node.py

@@ -2,44 +2,93 @@ from util import recherche_dichotomique
 
 class Node() :
     
-    def __init__(self, k) :
-        self.parent =
-        self.keys = []
-        self.childs = []
+    def __init__(self, keys, childs = [], k = 2) :
+        self.keys = keys
+        self.childs = childs
         self.k = k
         
-    def isLeaf():
+    def isLeaf(self):
+        """
+        >>> Node([12, 42]).isLeaf()
+        True
+        >>> Node([12, 42], [Node([1]), Node([25]), Node([50])]).isLeaf()
+        False
+        """
         return (len(self.childs) == 0)
                     
     def getSize(self) :
         return len(Keys)
     
-    def serach(self, value):
+    def search(self, value):
+        """
+        >>> Node([5, 25]).search(5)
+        (Node([5, 25]),0)
+        >>> Node([5,25],[Node[1],Node[18],Node[100]]).search(18)
+        (Node[18],0)
+        """
         (found, index) = recherche_dichotomique(value, self.keys)
         if (found):
-            return (node, index)
-        elif ( node.isLeaf() ):
+            return (self, index)
+        elif ( self.isLeaf() ):
             return None
         else :
             self.childs[index].search(value)
     
-    def insert_not_full(self, value):
+    def insert(self, value, k):
+        """
+        >>> Node([5,15]).insert(12, 3)
+        Node([5,12,15])
+        >>> Node([5,15]).insert(20, 4)
+        Node([5,15,20])
+        """
         (found, index) = self.search(value)
         if (self.isLeaf()) :
             if (not found):
-                self.keys.insert() = value
+                self.keys.insert(index, value)
         else :
-            if (len(self.childs[index]) == self.k) :
-                self.childs[index].splitNode(index)
-                if (value > self.keys[index]) :
-                    index += 1
-            self.childs[index].insert_not_full(value)
+            (fini, milieu, g, d) = self.childs[index].insert(value, k)
+            if not fini:
+                return None
+            #TODO
+        if (len(self.keys) > k) :
+            (m, g, d) = self.splitNode()
+            f = False
+        else:
+            return None
+            #TODO
+            
+
+
+#     def splitNode(self) :
+#         parent = Node(self.k)
+#         m = self.keys[(len(self.node.keys))//2]
 
-# j'ai pas encore bien compris comment m'y prendre
     def splitNode(self) :
-        parent = Node(self.k)
-        m = self.keys[(len(self.node.keys))//2]
+        """
+        >>> Node([10,20,25]).splitNode()
+        (20, Node([10]), Node([25])
+        """
+        milieu = len(self.keys) //2
+        parent = self.keys[milieu]
+        g = Node(self.keys[:milieu], self.childs[:milieu+1])
+        d = Node(self.keys[milieu+1:], self.childs[milieu+1:])
         
+        return (milieu,g,d)
+            
+
+
+
+
+
+
+
+
+
+
+
+
+
+
         
             
             
@@ -49,4 +98,8 @@ class Node() :
     #def setNewChild() :
     #def removeChild() :    
     
-    #def isLeaf() :
+    #def isLeaf() :
\ No newline at end of file
+        
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod(verbose=True)
\ No newline at end of file

src/util.py

@@ -70,24 +70,6 @@ def recherche_dichotomique(x, l, cmp = compare):
                    for j in range(len(l)))
     return (False, index)
 
-## LOIC
-    def dicho(self, listKeys,key) :
-        t=len(listKeys)-1
-        d, f = 0, t        
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod(verbose=True)
\ No newline at end of file
-        while (f>= d) :
-            m=(d+f)//2
-            
-            if (listKeys[m]==key) :
-                return m
-            if (listKeys[m]>key):
-                f=m - 1
-                #if ( f< t and listKeys[f] == key) :
-                 #   return True,f
-            else :
-                d=m + 1
-                #if (d < t and listKeys[d] == key) :
-                 #   return True, d           
-            
-        return -1
-
-doctest.testmod()
\ No newline at end of file