save

Author: happy-san

Diff for: lib/trees/threaded_binary_tree.dart

@@ -1,18 +1,18 @@
 import 'adt/binary_tree_adt.dart';
-import 'binary_tree.dart';
+//import 'binary_tree.dart';
 
 /// Data structure similar to [BinaryNode], differs in having two boolean values
 ///  [leftIsThread] and [rightIsThread] to determine whether [left] and [right]
 ///  are threads or point to a child instead.
 class ThreadedBinaryNode<V extends Comparable>
-    extends BinaryNodeADT<ThreadedBinaryNode, V> {
-  V value;
+    extends BinaryNodeADT<ThreadedBinaryNode<V>, V> {
+  V? value;
 
   /// Stores if [left] is a thread.
-  bool leftIsThread;
+  bool? leftIsThread;
 
   /// Stores if [right] is a thread.
-  bool rightIsThread;
+  bool? rightIsThread;
 
   ThreadedBinaryNode(this.value,
       {this.leftIsThread = true, this.rightIsThread = true});
@@ -25,8 +25,8 @@ class ThreadedBinaryNode<V extends Comparable>
 ///  (if it exists), and all [left] pointers that would normally be null point
 ///  to the in-order predecessor of the node.
 class ThreadedBinaryTree<V extends Comparable>
-    extends BinaryTreeADT<ThreadedBinaryNode, V> {
-  ThreadedBinaryNode root;
+    extends BinaryTreeADT<ThreadedBinaryNode<V>, V> {
+  ThreadedBinaryNode<V>? root;
 
   /// Creates an empty Threaded Binary tree.
   ThreadedBinaryTree();
@@ -49,17 +49,17 @@ class ThreadedBinaryTree<V extends Comparable>
       return;
     }
 
-    ThreadedBinaryNode parent, node = root;
-    var isPresent = false;
+    late ThreadedBinaryNode<V> parent;
+    var node = root, isPresent = false;
 
     while (node != null) {
-      if (node.value.compareTo(value) == 0) {
+      if (node.value!.compareTo(value) == 0) {
         isPresent = true;
         break;
       }
 
       parent = node;
-      if (node.value.compareTo(value) > 0) {
+      if (node.value!.compareTo(value) > 0) {
         if (!(node.leftIsThread ?? true)) {
           node = node.left;
         } else {
@@ -75,7 +75,7 @@ class ThreadedBinaryTree<V extends Comparable>
     if (!isPresent) {
       var newNode = ThreadedBinaryNode(value);
 
-      if (parent.value.compareTo(value) > 0) {
+      if (parent.value!.compareTo(value) > 0) {
         newNode.left = parent.left;
         newNode.right = parent;
 
@@ -97,39 +97,42 @@ class ThreadedBinaryTree<V extends Comparable>
     }
   }
 
+  @override
+  bool contains(V value) => inOrder().contains(value);
+
   @override
   void delete(V value) {
-    ThreadedBinaryNode parent, node = root;
-    var isPresent = false;
+    ThreadedBinaryNode<V>? parent;
+    var node = root, isPresent = false;
 
     while (node != null) {
-      if (node.value.compareTo(value) == 0) {
+      if (node.value!.compareTo(value) == 0) {
         isPresent = true;
         break;
       }
 
       parent = node;
-      if (node.value.compareTo(value) > 0) {
-        if (!node.leftIsThread) {
+      if (node.value!.compareTo(value) > 0) {
+        if (!(node.leftIsThread ?? true)) {
           node = node.left;
         } else {
           break;
         }
-      } else if (!node.rightIsThread) {
+      } else if (!(node.rightIsThread ?? true)) {
         node = node.right;
       } else {
         break;
       }
     }
 
     if (isPresent) {
-      if (!node.leftIsThread && !node.rightIsThread) {
+      if (!(node!.leftIsThread ?? true) && !(node.rightIsThread ?? true)) {
         // Node has 2 children.
         _delete(parent, node, _DeleteCase.twoChildren);
-      } else if (!node.leftIsThread) {
+      } else if (!(node.leftIsThread ?? true)) {
         // Node has only a left child.
         _delete(parent, node, _DeleteCase.oneChild);
-      } else if (!node.rightIsThread) {
+      } else if (!(node.rightIsThread ?? true)) {
         // Node has only a right child.
         _delete(parent, node, _DeleteCase.oneChild);
       } else {
@@ -145,12 +148,12 @@ class ThreadedBinaryTree<V extends Comparable>
     if (isEmpty) return result;
 
     var node = root;
-    while (node.leftIsThread != null) {
+    while (node!.leftIsThread != null) {
       node = node.left;
     }
 
     while (node != null) {
-      result.add(node.value);
+      result.add(node.value!);
       node = _inOrderSuccessor(node);
     }
     return result;
@@ -163,7 +166,7 @@ class ThreadedBinaryTree<V extends Comparable>
 
     var node = root;
     while (node != null) {
-      result.add(node.value);
+      result.add(node.value!);
       if (!(node.leftIsThread ?? true)) {
         node = node.left;
       } else if (!(node.rightIsThread ?? true)) {
@@ -181,23 +184,23 @@ class ThreadedBinaryTree<V extends Comparable>
     return result;
   }
 
-  void _delete(ThreadedBinaryNode parent, ThreadedBinaryNode node,
+  void _delete(ThreadedBinaryNode<V>? parent, ThreadedBinaryNode<V> node,
       _DeleteCase deleteCase) {
     switch (deleteCase) {
       case _DeleteCase.childless:
         if (parent == null) {
           nullify();
         } else if (node == parent.left) {
-          parent.leftIsThread = true;
+          parent.leftIsThread = node.leftIsThread == null ? null : true;
           parent.left = node.left;
         } else {
-          parent.rightIsThread = true;
+          parent.rightIsThread = node.rightIsThread == null ? null : true;
           parent.right = node.right;
         }
         break;
 
       case _DeleteCase.oneChild:
-        var child = node.leftIsThread ? node.right : node.left;
+        var child = node.leftIsThread! ? node.right : node.left;
 
         if (parent == null) {
           root = child;
@@ -209,28 +212,26 @@ class ThreadedBinaryTree<V extends Comparable>
 
         var successor = _inOrderSuccessor(node);
         var predecessor = _inOrderPredecessor(node);
-        if (!node.leftIsThread) {
-          predecessor.right = successor;
+        if (!(node.leftIsThread ?? true)) {
+          predecessor!.right = successor;
         } else {
-          if (!node.rightIsThread) {
-            successor.left = predecessor;
+          if (!(node.rightIsThread ?? true)) {
+            successor!.left = predecessor;
           }
         }
         break;
 
       case _DeleteCase.twoChildren:
-        ThreadedBinaryNode successor, parentSuccessor;
-        parentSuccessor = node;
-        successor = node.right;
+        var successor = node.right!, parentSuccessor = node;
 
-        while (successor.left != null) {
+        while (successor.left != null && !successor.leftIsThread!) {
           parentSuccessor = successor;
-          successor = successor.left;
+          successor = successor.left!;
         }
 
         node.value = successor.value;
 
-        if (successor.leftIsThread && successor.rightIsThread) {
+        if (successor.leftIsThread! && (successor.rightIsThread ?? true)) {
           _delete(parentSuccessor, successor, _DeleteCase.childless);
         } else {
           _delete(parentSuccessor, successor, _DeleteCase.oneChild);
@@ -239,27 +240,27 @@ class ThreadedBinaryTree<V extends Comparable>
     }
   }
 
-  ThreadedBinaryNode _inOrderPredecessor(ThreadedBinaryNode node) {
+  ThreadedBinaryNode<V>? _inOrderPredecessor(ThreadedBinaryNode<V> node) {
     if (node.leftIsThread ?? true) {
       return node.left;
     } else {
-      node = node.left;
+      node = node.left!;
 
-      while (!node.rightIsThread) {
-        node = node.right;
+      while (!node.rightIsThread!) {
+        node = node.right!;
       }
       return node;
     }
   }
 
-  ThreadedBinaryNode _inOrderSuccessor(ThreadedBinaryNode node) {
+  ThreadedBinaryNode<V>? _inOrderSuccessor(ThreadedBinaryNode<V> node) {
     if (node.rightIsThread ?? true) {
       return node.right;
     } else {
-      node = node.right;
+      node = node.right!;
 
-      while (!node.leftIsThread) {
-        node = node.left;
+      while (!node.leftIsThread!) {
+        node = node.left!;
       }
       return node;
     }

Diff for: test/trees/red_black_tree_test.dart

@@ -85,6 +85,7 @@ void main() {
     });
   });
 
+  // TODO: Use isTrue, isFalse and equals().
   test('Add node', () {
     var test = RedBlackTree();
     var list = test.inOrder();