binary-search-tree: re-implement exercise according to canonical data (#1340)

* binary-search-tree: re-implement exercise according to canonical data

* binary-search-tree: fix import bug in tests

exercises/binary-search-tree/example.py

@@ -1,61 +1,51 @@
-from collections import deque
-
-
 class TreeNode(object):
-    def __init__(self, value):
-        self.value = value
-        self.left_node = None
-        self.right_node = None
+    def __init__(self, data, left, right):
+        self.data = data
+        self.left = left
+        self.right = right
 
     def __str__(self):
-        return str(self.value)
+        fmt = 'TreeNode(data={}, left={}, right={})'
+        return fmt.format(self.data, self.left, self.right)
 
 
 class BinarySearchTree(object):
-    def __init__(self):
+    def __init__(self, tree_data):
         self.root = None
+        for data in tree_data:
+            self.add(data)
 
-    def add(self, value):
-        if(self.root is None):
-            self.root = TreeNode(value)
-        else:
-            inserted = False
-            cur_node = self.root
-
-            while not inserted:
-                if(value <= cur_node.value):
-                    if(cur_node.left_node):
-                        cur_node = cur_node.left_node
-                    else:
-                        cur_node.left_node = TreeNode(value)
-                        inserted = True
-                elif(value > cur_node.value):
-                    if(cur_node.right_node):
-                        cur_node = cur_node.right_node
-                    else:
-                        cur_node.right_node = TreeNode(value)
-                        inserted = True
-
-    def search(self, value):
+    def add(self, data):
+        if self.root is None:
+            self.root = TreeNode(data, None, None)
+            return
+        inserted = False
         cur_node = self.root
-        found = False
-        while not found:
-            if(cur_node is None):
-                return None
-            elif(value < cur_node.value):
-                cur_node = cur_node.left_node
-            elif(value > cur_node.value):
-                cur_node = cur_node.right_node
-            elif(value == cur_node.value):
-                return cur_node
 
-    def list(self):
-        elements = deque()
-        self.trav_inorder(self.root, elements)
+        while not inserted:
+            if data <= cur_node.data:
+                if cur_node.left:
+                    cur_node = cur_node.left
+                else:
+                    cur_node.left = TreeNode(data, None, None)
+                    inserted = True
+            elif data > cur_node.data:
+                if cur_node.right:
+                    cur_node = cur_node.right
+                else:
+                    cur_node.right = TreeNode(data, None, None)
+                    inserted = True
+
+    def _inorder_traverse(self, node, elements):
+        if node is not None:
+            self._inorder_traverse(node.left, elements)
+            elements.append(node.data)
+            self._inorder_traverse(node.right, elements)
+
+    def data(self):
+        return self.root
+
+    def sorted_data(self):
+        elements = []
+        self._inorder_traverse(self.root, elements)
         return elements
-
-    def trav_inorder(self, node, elements):
-        if(node is not None):
-            self.trav_inorder(node.left_node, elements)
-            elements.append(node.value)
-            self.trav_inorder(node.right_node, elements)