Add functions in ThreadedBinaryTree.

Author: happy-san

Diff for: lib/trees/threaded_binary_tree.dart

@@ -13,8 +13,13 @@ class ThreadedBinaryNode<V extends Comparable>
 
   /// Stores if [right] is a thread.
   bool rightIsThread;
+
+  ThreadedBinaryNode(this.value,
+      {this.leftIsThread = true, this.rightIsThread = true});
 }
 
+enum _DeleteCase { twoChildren, oneChild, childless }
+
 /// A [BinaryTree] is threaded by making all [right] pointers that would
 ///  normally be null point to the in-order successor of the node
 ///  (if it exists), and all [left] pointers that would normally be null point
@@ -25,21 +30,213 @@ class ThreadedBinaryTree<V extends Comparable>
 
   @override
   void add(V value) {
-    throw UnimplementedError();
+    ThreadedBinaryNode parent, node = root;
+    var isPresent = false;
+
+    while (node != null) {
+      if (node.value.compareTo(value) == 0) {
+        isPresent = true;
+        break;
+      }
+
+      parent = node;
+      if (node.value.compareTo(value) > 0) {
+        if (!node.leftIsThread) {
+          node = node.left;
+        } else {
+          break;
+        }
+      } else if (!node.rightIsThread) {
+        node = node.right;
+      } else {
+        break;
+      }
+    }
+
+    if (!isPresent) {
+      var newNode = ThreadedBinaryNode(value);
+
+      if (parent == null) {
+        root = newNode;
+      } else if (parent.value.compareTo(value) > 0) {
+        newNode.left = parent.left;
+        newNode.right = parent;
+        parent.leftIsThread = false;
+        parent.left = newNode;
+      } else {
+        newNode.left = parent;
+        newNode.right = parent.right;
+        parent.rightIsThread = false;
+        parent.right = newNode;
+      }
+    }
   }
 
   @override
   void delete(V value) {
-    throw UnimplementedError();
+    ThreadedBinaryNode parent, node = root;
+    var isPresent = false;
+
+    while (node != null) {
+      if (node.value.compareTo(value) == 0) {
+        isPresent = true;
+        break;
+      }
+
+      parent = node;
+      if (node.value.compareTo(value) > 0) {
+        if (!node.leftIsThread) {
+          node = node.left;
+        } else {
+          break;
+        }
+      } else if (!node.rightIsThread) {
+        node = node.right;
+      } else {
+        break;
+      }
+    }
+
+    if (isPresent) {
+      if (!node.leftIsThread && !node.rightIsThread) {
+        // Node has 2 children.
+        _delete(parent, node, _DeleteCase.twoChildren);
+      } else if (!node.leftIsThread) {
+        // Node has only a left child.
+        _delete(parent, node, _DeleteCase.oneChild);
+      } else if (!node.rightIsThread) {
+        // Node has only a right child.
+        _delete(parent, node, _DeleteCase.oneChild);
+      } else {
+        // Node is childless.
+        _delete(parent, node, _DeleteCase.childless);
+      }
+    }
+  }
+
+  void _delete(ThreadedBinaryNode parent, ThreadedBinaryNode node,
+      _DeleteCase deleteCase) {
+    switch (deleteCase) {
+      case _DeleteCase.childless:
+        if (parent == null) {
+          nullify();
+        } else if (node == parent.left) {
+          parent.leftIsThread = true;
+          parent.left = node.left;
+        } else {
+          parent.rightIsThread = true;
+          parent.right = node.right;
+        }
+        break;
+
+      case _DeleteCase.oneChild:
+        var child = node.leftIsThread ? node.right : node.left;
+
+        if (parent == null) {
+          root = child;
+        } else if (node == parent.left) {
+          parent.left = child;
+        } else {
+          parent.right = child;
+        }
+
+        var successor = _inOrderSuccessor(node);
+        var predecessor = _inOrderPredecessor(node);
+        if (!node.leftIsThread) {
+          predecessor.right = successor;
+        } else {
+          if (!node.rightIsThread) {
+            successor.left = predecessor;
+          }
+        }
+        break;
+
+      case _DeleteCase.twoChildren:
+        ThreadedBinaryNode successor, parentSuccessor;
+        parentSuccessor = node;
+        successor = node.right;
+
+        while (successor.left != null) {
+          parentSuccessor = successor;
+          successor = successor.left;
+        }
+
+        node.value = successor.value;
+
+        if (successor.leftIsThread && successor.rightIsThread) {
+          _delete(parentSuccessor, successor, _DeleteCase.childless);
+        } else {
+          _delete(parentSuccessor, successor, _DeleteCase.oneChild);
+        }
+        break;
+    }
   }
 
   @override
   List<V> inOrder() {
-    throw UnimplementedError();
+    var result = <V>[];
+    if (isEmpty) return result;
+
+    var node = root;
+    while (!node.leftIsThread) {
+      node = node.left;
+    }
+
+    while (node.rightIsThread) {
+      result.add(node.value);
+      node = _inOrderSuccessor(node);
+    }
+    return result;
   }
 
   @override
   List<V> preOrder() {
-    throw UnimplementedError();
+    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) {
+        node = node.right;
+      } else {
+        while (node != null && node.rightIsThread) {
+          node = node.right;
+        }
+
+        if (node != null) {
+          node = node.right;
+        }
+      }
+    }
+    return result;
+  }
+
+  ThreadedBinaryNode _inOrderSuccessor(ThreadedBinaryNode node) {
+    if (node.rightIsThread) {
+      return node.right;
+    } else {
+      node = node.right;
+
+      while (!node.leftIsThread) {
+        node = node.left;
+      }
+      return node;
+    }
+  }
+
+  ThreadedBinaryNode _inOrderPredecessor(ThreadedBinaryNode node) {
+    if (node.leftIsThread) {
+      return node.left;
+    } else {
+      node = node.left;
+
+      while (!node.rightIsThread) {
+        node = node.right;
+      }
+      return node;
+    }
   }
 }