public ThreadedBinaryTree <T> BuildThreadedTree()
{
ThreadedBinaryTreeDummyNode <T> dummy = new ThreadedBinaryTreeDummyNode <T>();
ThreadedBinaryTreeNode <T> root = BuildThreadedTree(Root, dummy, dummy);
dummy.AddChild(root);
return(new ThreadedBinaryTree <T>(dummy));
}
public void InOrderTraverse(Action <ThreadedBinaryTreeNode <T> > action)
{
ThreadedBinaryTreeNode <T> successor = GetInOrderSuccessor(this.dummy);
while (!ReferenceEquals(successor, this.dummy))
{
action(successor);
successor = GetInOrderSuccessor(successor);
}
}
protected ThreadedBinaryTreeNode <T> GetPreOrderSuccessor(ThreadedBinaryTreeNode <T> node)
{
if (!node.IsLeftThreaded)
{
return(node.Left);
}
while (node.IsRightThreaded)
{
node = node.Right;
}
return(node.Right);
}
public ThreadedBinaryTreeNode <T> RemoveRight()
{
if (IsRightThreaded)
{
throw new InvalidOperationException();
}
ThreadedBinaryTreeNode <T> result = Right;
ThreadedBinaryTreeNode <T> right = Right;
this.isRightThreaded = true;
while (!right.IsRightThreaded)
{
right = right.Right;
}
SetRight(right.Right);
return(result);
}
public ThreadedBinaryTreeNode <T> RemoveLeft()
{
if (IsLeftThreaded)
{
throw new InvalidOperationException();
}
ThreadedBinaryTreeNode <T> result = Left;
ThreadedBinaryTreeNode <T> left = Left;
this.isLeftThreaded = true;
while (!left.IsLeftThreaded)
{
left = left.Left;
}
SetLeft(left.Left);
return(result);
}
public ThreadedBinaryTreeNode <T> InsertRight(T value)
{
ThreadedBinaryTreeNode <T> node = new ThreadedBinaryTreeNode <T>(value);
ThreadedBinaryTreeNode <T> right = Right;
bool isRT = IsRightThreaded;
SetRight(node);
this.isRightThreaded = false;
node.SetRight(right);
node.isRightThreaded = isRT;
node.isLeftThreaded = true;
node.SetLeft(this);
if (!isRT)
{
ThreadedBinaryTreeNode <T> n = right;
while (!n.isLeftThreaded)
{
n = n.Left;
}
n.SetLeft(node);
}
return(node);
}
internal ThreadedBinaryTreeNode <T> BuildThreadedTree(BinaryTreeNodeBase <T> root, ThreadedBinaryTreeNode <T> nodeParent, ThreadedBinaryTreeNode <T> nodeRecentVisited)
{
if (root == null)
{
return(null);
}
bool isLeftThreaded = (root.Left == null);
bool isRightThreaded = (root.Right == null);
ThreadedBinaryTreeNode <T> node = new ThreadedBinaryTreeNode <T>(root.Value, isLeftThreaded, null, isRightThreaded, null);
ThreadedBinaryTreeNode <T> left = BuildThreadedTree(root.Left, node, nodeRecentVisited);
ThreadedBinaryTreeNode <T> right = BuildThreadedTree(root.Right, nodeParent, node);
if (isLeftThreaded)
{
left = nodeRecentVisited;
}
if (isRightThreaded)
{
right = nodeParent;
}
node.AddChild(left);
node.AddChild(right);
return(node);
}
public ThreadedBinaryTree(ThreadedBinaryTreeNode <T> root)
: this(new ThreadedBinaryTreeDummyNode <T>(root))
{
}
internal ThreadedBinaryTreeNode(T value, ThreadedBinaryTreeNode <T> left) : base(value, left, null)
{
SetRight(this);
}
public ThreadedBinaryTreeNode(T value, bool isLeftThreaded, ThreadedBinaryTreeNode <T> left, bool isRightThreaded, ThreadedBinaryTreeNode <T> right) : base(value, left, right)
{
this.isLeftThreaded = isLeftThreaded;
this.isRightThreaded = isRightThreaded;
}
public ThreadedBinaryTreeNode(T value, ThreadedBinaryTreeNode <T> left, ThreadedBinaryTreeNode <T> right)
: this(value, false, left, false, right)
{
}
public ThreadedBinaryTreeDummyNode(ThreadedBinaryTreeNode <T> root)
: base(default(T), root)
{
}
