/// <summary>
/// Sets the child in the given branch.
/// </summary>
public void SetChild(Branch branch, DecompositionNode child)
{
if (branch == Branch.Left)
{
this.Left = child;
}
else
{
this.Right = child;
}
}
/// <summary>
/// A deep copy of this subtree.
/// </summary>
/// <param name="tree">The original tree.</param>
/// <param name="parent">The parent of the copied node.</param>
/// <returns>A deep copy of the node.</returns>
public DecompositionNode CopyTree(DecompositionTree tree, DecompositionNode parent)
{
DecompositionNode node = tree.Nodes[this.Index] = new DecompositionNode(this, tree);
node.Parent = parent;
if (!this.IsLeaf)
{
node.Left = this.Left.CopyTree(tree, node);
node.Right = this.Right.CopyTree(tree, node);
}
return(node);
}
/// <summary>
/// Attach the child to the parent in the specific branch. Set the child as the root of the tree if no parent is provided.
/// </summary>
public void Attach(DecompositionNode parent, DecompositionNode child, Branch branch)
{
child.Parent = parent;
child.Branch = branch;
if (parent == null)
{
this.Root = child;
}
else
{
parent.SetChild(branch, child);
}
}
public DecompositionNode(DecompositionNode node, DecompositionTree tree = null)
{
this.Set = new BitSet(node.Set);
this.Left = node.Left;
this.Right = node.Right;
this.Parent = node.Parent;
this.Branch = node.Branch;
this.Width = node.Width;
this.SubTreeWidth = node.SubTreeWidth;
this.SubTreeSum = node.SubTreeSum;
this.Index = node.Index;
this.vertex = node.vertex;
this.Tree = tree != null ? tree : node.Tree;
}
/// <summary>
/// Returns the node at the given position. The position index of a parent is one plus the index of the right child; the position of the left child is less than the position of the right child.
/// </summary>
public DecompositionNode Find(int position)
{
int offset = 0;
DecompositionNode result = this.Root;
while (offset + result.SubTreeSize != position)
{
if (position <= offset + result.Left.SubTreeSize)
{
result = result.Left;
}
else
{
offset += result.Left.SubTreeSize;
result = result.Right;
}
}
return(result);
}
/// <summary>
/// The set of all nodes in this subtree.
/// </summary>
/// <param name="mode">The order in which we will travers the nodes in the subtree.</param>
/// <returns>The nodes in the subtree.</returns>
public IEnumerable <DecompositionNode> SubTree(TreeTraversal mode)
{
if (mode == TreeTraversal.ParentFirst)
{
Queue <DecompositionNode> queue = new Queue <DecompositionNode>();
queue.Enqueue(this);
while (queue.Count > 0)
{
DecompositionNode node = queue.Dequeue();
if (!node.IsLeaf)
{
queue.Enqueue(node.Left);
queue.Enqueue(node.Right);
}
yield return(node);
}
}
else
{
DecompositionNode finished = this;
Stack <DecompositionNode> stack = new Stack <DecompositionNode>();
stack.Push(this);
while (stack.Count > 0)
{
DecompositionNode node = stack.Peek();
if (node.IsLeaf || node.Right == finished)
{
stack.Pop();
finished = node;
yield return(node);
}
else
{
stack.Push(node.Right);
stack.Push(node.Left);
}
}
}
}