Refactor node traversal tests and identify issues.

Author: jeromekelleher

python/tests/__init__.py

@@ -83,80 +83,6 @@ def children(self, u):
             v = self.right_sib[v]
         return ret
 
-    def _preorder_nodes(self, u, node_ist):
-        node_ist.append(u)
-        for c in self.children(u):
-            self._preorder_nodes(c, node_ist)
-
-    def _postorder_nodes(self, u, node_ist):
-        for c in self.children(u):
-            self._postorder_nodes(c, node_ist)
-        node_ist.append(u)
-
-    def _inorder_nodes(self, u, node_ist):
-        children = self.children(u)
-        if len(children) > 0:
-            mid = len(children) // 2
-            for v in children[:mid]:
-                self._inorder_nodes(v, node_ist)
-            node_ist.append(u)
-            for v in children[mid:]:
-                self._inorder_nodes(v, node_ist)
-        else:
-            node_ist.append(u)
-
-    def _levelorder_nodes(self, u, node_ist, level):
-        node_ist[level].append(u) if level < len(node_ist) else node_ist.append([u])
-        for c in self.children(u):
-            self._levelorder_nodes(c, node_ist, level + 1)
-
-    def _minlex_postorder_nodes(self, u, node_ist):
-        node_ist.extend(self._minlex_postorder_nodes_helper(u)[1])
-
-    def _minlex_postorder_nodes_helper(self, u):
-        """
-        For a given input ID u, this function returns a tuple whose first value
-        is the minimum leaf node ID under node u, and whose second value is
-        a list containing the minlex postorder for the subtree rooted at node u.
-        The first value is needed for sorting, and the second value is what
-        finally gets returned.
-        """
-        children = self.children(u)
-        if len(children) > 0:
-            children_return = [self._minlex_postorder_nodes_helper(c) for c in children]
-            # sorts by first value, which is the minimum leaf node ID
-            children_return.sort()
-            minlex_postorder = []
-            for _, child_minlex_postorder in children_return:
-                minlex_postorder.extend(child_minlex_postorder)
-            minlex_postorder.extend([u])
-            return (children_return[0][0], minlex_postorder)
-        else:
-            return (u, [u])
-
-    def nodes(self, root=None, order="preorder"):
-        roots = [root]
-        if root is None:
-            roots = self.roots
-        for u in roots:
-            node_list = []
-            if order == "preorder":
-                self._preorder_nodes(u, node_list)
-            elif order == "inorder":
-                self._inorder_nodes(u, node_list)
-            elif order == "postorder":
-                self._postorder_nodes(u, node_list)
-            elif order == "levelorder" or order == "breadthfirst":
-                # Returns nodes in their respective levels
-                # Nested list comprehension flattens node_list in order
-                self._levelorder_nodes(u, node_list, 0)
-                node_list = iter([i for level in node_list for i in level])
-            elif order == "minlex_postorder":
-                self._minlex_postorder_nodes(u, node_list)
-            else:
-                raise ValueError("order not supported")
-            yield from node_list
-
     def get_interval(self):
         return self.left, self.right