public bool InOrderTreeWalk(TreeWalkAction <T> action) { if (Root != null) { Stack <Node> stack = new Stack <Node>(2 * ((int)Math.Log(Count + 1))); Node r = Root; while (r != null) { stack.Push(r); r = r.Left; } while (stack.Count != 0) { r = stack.Pop(); if (!action(r)) { return(false); } for (Node node2 = r.Right; node2 != null; node2 = node2.Left) { stack.Push(node2); } } } return(true); }
// // Do a in order walk on tree and calls the delegate for each node. // If the action delegate returns false, stop the walk. // // Return true if the entire tree has been walked. // Otherwise returns false. // internal bool InOrderTreeWalk(TreeWalkAction <T> action) { if (root == null) { return(true); } // The maximum height of a red-black tree is 2*lg(n+1). // See page 264 of "Introduction to algorithms" by Thomas H. Cormen Stack <Node> stack = new Stack <Node>(2 * (int)Math.Log(Count + 1)); Node current = root; while (current != null) { stack.Push(current); current = current.Left; } while (stack.Count != 0) { current = stack.Pop(); if (!action(current)) { return(false); } Node node = current.Right; while (node != null) { stack.Push(node); node = node.Left; } } return(true); }
/// <summary> /// Accepts the specified visitor and allow it to visit every node of the /// tree. /// </summary> /// <param name="visitor">The visitor to accepts.</param> /// <param name="reverse">A value indicating if the elements will be visit /// in the reverse order or not.</param> /// <param name="state">A user-defined object that qualifies or contains /// information about the visitor's current state.</param> /// <exception cref="ArgumentNullException"><paramref name="visitor"/> is /// a null reference</exception> public void Accept(InOrderVisitor <TValue> visitor, object state, bool reverse) { if (visitor == null) { throw new ArgumentNullException("visitor"); } TreeWalkAction <TKey, TValue> on_tree_walk = new TreeWalkAction <TKey, TValue>( delegate(AndersonTreeNode <TKey, TValue> node) { visitor.Visit(node.Value, state); return(!visitor.IsCompleted); }); if (reverse) { ReverseInOrderTreeWalk(on_tree_walk); } else { InOrderTreeWalk(on_tree_walk); } }
internal void InOrderTreeWalk(Node start, TreeWalkAction <Key, Value> action, TreeWalkTerminationPredicate <Key, Value> terminationPredicate) { Node node = start; while (node != null && !terminationPredicate(node)) { action(node); node = node.Next; } }
/// <summary> /// Performs reverse in-order traversal on the /// <see cref="AndersonTree{TKey,TValue}"/> /// </summary> /// <param name="action"> /// A method used to perform some action with each node in the tree. /// </param> /// <remarks> /// The <paramref name="action"/> must return <c>true</c> in order to /// allows the traversal to continue. /// </remarks> internal bool ReverseInOrderTreeWalk(TreeWalkAction <TKey, TValue> action) { if (root_.Level != 0) { Stack <AndersonTreeNode <TKey, TValue> > stack = new Stack <AndersonTreeNode <TKey, TValue> > (2 * ((int)Math.Log((double)(count_ + 1)))); AndersonTreeNode <TKey, TValue> node = root_; // traverse the left branch of the tree until reach a sentinel_ node. while (node.Level != 0) { stack.Push(node); node = node.Right; } while (stack.Count != 0) { node = stack.Pop(); if (!action(node)) { return(false); } // traverse the right branch of the current node and store then into // the execution stack. for (AndersonTreeNode <TKey, TValue> node2 = node.Left; node2.Level != 0; node2 = node2.Right) { stack.Push(node2); } } } return(true); }
internal bool InOrderTreeWalk(TreeWalkAction <T> action) { if (this.root != null) { Stack <TreeSet <T> .Node> stack = new Stack <TreeSet <T> .Node>(2 * (int)System.Math.Log((double)(this.Count + 1))); for (TreeSet <T> .Node node = this.root; node != null; node = node.Left) { stack.Push(node); } while (stack.Count != 0) { TreeSet <T> .Node node = stack.Pop(); if (!action(node)) { return(false); } for (TreeSet <T> .Node node2 = node.Right; node2 != null; node2 = node2.Left) { stack.Push(node2); } } } return(true); }