Add test for ThreadedBinaryTree

Author: happy-san

lib/trees/threaded_binary_tree.dart

@@ -16,9 +16,9 @@ class ThreadedBinaryNode<V extends Comparable>
 
   ThreadedBinaryNode(this.value,
       {this.leftIsThread = true, this.rightIsThread = true});
-}
 
-enum _DeleteCase { twoChildren, oneChild, childless }
+  ThreadedBinaryNode.root(this.value);
+}
 
 /// A [BinaryTree] is threaded by making all [right] pointers that would
 ///  normally be null point to the in-order successor of the node
@@ -28,8 +28,27 @@ class ThreadedBinaryTree<V extends Comparable>
     extends BinaryTreeADT<ThreadedBinaryNode, V> {
   ThreadedBinaryNode root;
 
+  /// Creates an empty Threaded Binary tree.
+  ThreadedBinaryTree();
+
+  /// Creates a Threaded Binary tree with all the values of [list].
+  ThreadedBinaryTree.fromList(List<V> list) {
+    for (var value in list) {
+      add(value);
+    }
+  }
+
+  /// Creates a new Threaded Binary tree with a single [value].
+  ThreadedBinaryTree.withSingleValue(V value)
+      : root = ThreadedBinaryNode.root(value);
+
   @override
   void add(V value) {
+    if (isEmpty) {
+      root = ThreadedBinaryNode.root(value);
+      return;
+    }
+
     ThreadedBinaryNode parent, node = root;
     var isPresent = false;
 
@@ -41,12 +60,12 @@ class ThreadedBinaryTree<V extends Comparable>
 
       parent = node;
       if (node.value.compareTo(value) > 0) {
-        if (!node.leftIsThread) {
+        if (!(node.leftIsThread ?? true)) {
           node = node.left;
         } else {
           break;
         }
-      } else if (!node.rightIsThread) {
+      } else if (!(node.rightIsThread ?? true)) {
         node = node.right;
       } else {
         break;
@@ -56,16 +75,22 @@ class ThreadedBinaryTree<V extends Comparable>
     if (!isPresent) {
       var newNode = ThreadedBinaryNode(value);
 
-      if (parent == null) {
-        root = newNode;
-      } else if (parent.value.compareTo(value) > 0) {
+      if (parent.value.compareTo(value) > 0) {
         newNode.left = parent.left;
         newNode.right = parent;
+
+        // Parent was the leftmost node of the tree.
+        newNode.leftIsThread = parent.leftIsThread ?? null;
+
         parent.leftIsThread = false;
         parent.left = newNode;
       } else {
         newNode.left = parent;
         newNode.right = parent.right;
+
+        // Parent was the rightmost node of the tree.
+        newNode.rightIsThread = parent.rightIsThread ?? null;
+
         parent.rightIsThread = false;
         parent.right = newNode;
       }
@@ -114,6 +139,48 @@ class ThreadedBinaryTree<V extends Comparable>
     }
   }
 
+  @override
+  List<V> inOrder() {
+    var result = <V>[];
+    if (isEmpty) return result;
+
+    var node = root;
+    while (node.leftIsThread != null) {
+      node = node.left;
+    }
+
+    while (node != null) {
+      result.add(node.value);
+      node = _inOrderSuccessor(node);
+    }
+    return result;
+  }
+
+  @override
+  List<V> preOrder() {
+    var result = <V>[];
+    if (isEmpty) return result;
+
+    var node = root;
+    while (node != null) {
+      result.add(node.value);
+      if (!(node.leftIsThread ?? true)) {
+        node = node.left;
+      } else if (!(node.rightIsThread ?? true)) {
+        node = node.right;
+      } else {
+        while (node != null && (node.rightIsThread ?? false)) {
+          node = node.right;
+        }
+
+        if (node != null) {
+          node = node.right;
+        }
+      }
+    }
+    return result;
+  }
+
   void _delete(ThreadedBinaryNode parent, ThreadedBinaryNode node,
       _DeleteCase deleteCase) {
     switch (deleteCase) {
@@ -172,50 +239,21 @@ class ThreadedBinaryTree<V extends Comparable>
     }
   }
 
-  @override
-  List<V> inOrder() {
-    var result = <V>[];
-    if (isEmpty) return result;
-
-    var node = root;
-    while (!node.leftIsThread) {
+  ThreadedBinaryNode _inOrderPredecessor(ThreadedBinaryNode node) {
+    if (node.leftIsThread ?? true) {
+      return node.left;
+    } else {
       node = node.left;
-    }
-
-    while (node.rightIsThread) {
-      result.add(node.value);
-      node = _inOrderSuccessor(node);
-    }
-    return result;
-  }
 
-  @override
-  List<V> preOrder() {
-    var result = <V>[];
-    if (isEmpty) return result;
-
-    var node = root;
-    while (node != null) {
-      result.add(node.value);
-      if (!node.leftIsThread) {
-        node = node.left;
-      } else if (!node.rightIsThread) {
+      while (!node.rightIsThread) {
         node = node.right;
-      } else {
-        while (node != null && node.rightIsThread) {
-          node = node.right;
-        }
-
-        if (node != null) {
-          node = node.right;
-        }
       }
+      return node;
     }
-    return result;
   }
 
   ThreadedBinaryNode _inOrderSuccessor(ThreadedBinaryNode node) {
-    if (node.rightIsThread) {
+    if (node.rightIsThread ?? true) {
       return node.right;
     } else {
       node = node.right;
@@ -226,17 +264,6 @@ class ThreadedBinaryTree<V extends Comparable>
       return node;
     }
   }
-
-  ThreadedBinaryNode _inOrderPredecessor(ThreadedBinaryNode node) {
-    if (node.leftIsThread) {
-      return node.left;
-    } else {
-      node = node.left;
-
-      while (!node.rightIsThread) {
-        node = node.right;
-      }
-      return node;
-    }
-  }
 }
+
+enum _DeleteCase { twoChildren, oneChild, childless }

test/trees/threaded_binary_tree_test.dart

@@ -0,0 +1,39 @@
+import 'package:algorithms/trees/threaded_binary_tree.dart';
+import 'package:test/test.dart';
+
+void main() {
+  ThreadedBinaryTree<String> empty, singleNode, multipleNodes;
+  List<ThreadedBinaryTree> treeList;
+
+  setUp(() {
+    empty = ThreadedBinaryTree();
+    singleNode = ThreadedBinaryTree.withSingleValue('@');
+    multipleNodes = ThreadedBinaryTree.fromList(
+        ['f', 'b', 'g', 'a', 'd', 'i', 'c', 'e', 'h']);
+    treeList = [singleNode, multipleNodes];
+  });
+
+  group('Traversal', () {
+    test('Pre-order', () {
+      expect(empty.preOrder(), <String>[]);
+      expect(singleNode.preOrder(), <String>['@']);
+      expect(multipleNodes.preOrder(),
+          equals(<String>['f', 'b', 'a', 'd', 'c', 'e', 'g', 'i', 'h']));
+    });
+
+    // Results in stack overflow.
+    test('Post-order', () {
+      expect(empty.postOrder(), <String>[]);
+      expect(singleNode.postOrder(), <String>['@']);
+      expect(multipleNodes.postOrder(),
+          equals(<String>['a', 'c', 'e', 'd', 'b', 'h', 'i', 'g', 'f']));
+    });
+
+    test('In-order', () {
+      expect(empty.inOrder(), <String>[]);
+      expect(singleNode.inOrder(), <String>['@']);
+      expect(multipleNodes.inOrder(),
+          equals(<String>['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']));
+    });
+  });
+}