public override void Clear()
 {
     root.Clear();
 }
 public virtual bool Remove(IntervalTree.TreeNode <E, T> node, T target)
 {
     if (target == null)
     {
         return(false);
     }
     if (node.value == null)
     {
         return(false);
     }
     if (target.Equals(node.value))
     {
         int leftSize  = (node.left != null) ? node.left.size : 0;
         int rightSize = (node.right != null) ? node.right.size : 0;
         if (leftSize == 0)
         {
             if (rightSize == 0)
             {
                 node.Clear();
             }
             else
             {
                 node.value  = node.right.value;
                 node.size   = node.right.size;
                 node.maxEnd = node.right.maxEnd;
                 node.left   = node.right.left;
                 node.right  = node.right.right;
                 if (node.left != null)
                 {
                     node.left.parent = node;
                 }
                 if (node.right != null)
                 {
                     node.right.parent = node;
                 }
             }
         }
         else
         {
             if (rightSize == 0)
             {
                 node.value  = node.left.value;
                 node.size   = node.left.size;
                 node.maxEnd = node.left.maxEnd;
                 node.left   = node.left.left;
                 node.right  = node.left.right;
                 if (node.left != null)
                 {
                     node.left.parent = node;
                 }
                 if (node.right != null)
                 {
                     node.right.parent = node;
                 }
             }
             else
             {
                 // Rotate left up
                 node.value = node.left.value;
                 node.size--;
                 node.maxEnd = Interval.Max(node.left.maxEnd, node.right.maxEnd);
                 IntervalTree.TreeNode <E, T> origRight = node.right;
                 node.right = node.left.right;
                 node.left  = node.left.left;
                 if (node.left != null)
                 {
                     node.left.parent = node;
                 }
                 if (node.right != null)
                 {
                     node.right.parent = node;
                 }
                 // Attach origRight somewhere...
                 IntervalTree.TreeNode <E, T> rightmost = GetRightmostNode(node);
                 rightmost.right = origRight;
                 if (rightmost.right != null)
                 {
                     rightmost.right.parent = rightmost;
                     // adjust maxEnd and sizes on the right
                     AdjustUpwards(rightmost.right, node);
                 }
             }
         }
         return(true);
     }
     else
     {
         if (target.GetInterval().CompareTo(node.value.GetInterval()) <= 0)
         {
             // Should go on left
             if (node.left == null)
             {
                 return(false);
             }
             bool res = Remove(node.left, target);
             if (res)
             {
                 node.maxEnd = Interval.Max(node.maxEnd, node.left.maxEnd);
                 node.size--;
             }
             return(res);
         }
         else
         {
             // Should go on right
             if (node.right == null)
             {
                 return(false);
             }
             bool res = Remove(node.right, target);
             if (res)
             {
                 node.maxEnd = Interval.Max(node.maxEnd, node.right.maxEnd);
                 node.size--;
             }
             return(res);
         }
     }
 }