/// <summary> /// Returns the subtree which is rooted in the vertex in the parameters. /// </summary> /// <param name="vertexId"> The root of the subtree. </param> /// <param name="copy"> If true: A new tree is returned. /// If false: The subtree is created using the original tree. </param> /// <returns> The subtree. </returns> public Tree SubTree(int vertexId, bool copy = true) { traversal t = new traversal(); if (!copy) { // Remove all vertices not in the Sub-tree IEnumerable <int> bunch = t.RecursivePreOrder((mtg)this, vertexId); foreach (int vid in parent.Keys) { if (!bunch.Contains(vid)) { RemoveVertex(vid); } } root = vertexId; if (parent.ContainsKey(root)) { parent[root] = -1; } else { parent.Add(root, -1); } return(this); } else { Dictionary <int, int> renumberedTree = new Dictionary <int, int>(); Tree tree = new Tree(); tree.root = 0; renumberedTree.Add(vertexId, tree.root); IEnumerable <int> subTree = t.RecursivePreOrder((mtg)this, vertexId); foreach (int vid in subTree) { if (vid != vertexId) { int parent = renumberedTree[(int)Parent(vid)]; int v = tree.AddChild(parent); renumberedTree.Add(vid, v); } } return(tree); } }
/// <summary> /// Add a tree after the children of the parent specified in the parameters. /// </summary> /// <param name="parentId"> Vertex identifier. </param> /// <param name="tree"> A rooted tree. </param> /// <returns> The dictionary which makes a correspondance between old identifier and new identifier. </returns> public Dictionary <int, int> AddChildTree(int parentId, Tree tree) { Dictionary <int, int> renumberedTree = new Dictionary <int, int>(); int root = tree.root; int rootId = AddChild(parentId); renumberedTree.Add(root, rootId); // PreOrder traversal from root and renumbering new children. traversal t = new traversal(); foreach (int vertexId in t.RecursivePreOrder((mtg)tree, root)) { if (vertexId == root) { continue; } parentId = renumberedTree[(int)tree.Parent(vertexId)]; int vid = AddChild(parentId); renumberedTree.Add(vertexId, vid); } return(renumberedTree); }
/// <summary> /// Insert a tree before the specified vertex. /// </summary> /// <param name="vertexId"> Vertex identifier. </param> /// <param name="tree"> The tree to be inserted. </param> /// <returns> The new identifiers after the sibling has been added. </returns> public Dictionary <int, int> InsertSiblingTree(int vertexId, Tree tree) { Dictionary <int, int> renumberedTree = new Dictionary <int, int>(); int root = tree.root; int rootId = InsertSibling(vertexId); renumberedTree.Add(root, rootId); // PreOrder traversal from root and renumbering the sibling's vertices. traversal t = new traversal(); foreach (int vertex in t.RecursivePreOrder((mtg)tree, vertexId)) { int parent = renumberedTree[(int)tree.Parent(vertex)]; int v = AddChild(parent); renumberedTree.Add(vertex, v); } return(renumberedTree); }
/// <summary> /// Return the subtree rooted on the vertex in the parameters. /// </summary> /// <param name="vertexId"> Vertex identifier. </param> /// <param name="copy"> If true: return a new tree holding the subtree. /// If false: The subtree is created using the original tree. </param> public new PropertyTree SubTree(int vertexId, bool copy = true) { traversal t = new traversal(); if (!copy) { IEnumerable <int> bunch = t.RecursivePreOrder((mtg)this, vertexId); IEnumerable <int> removeBunch = this.Vertices().Except(bunch); foreach (int vid in removeBunch) { RemoveVertexProperties(vid); // Remove parent edge int parentId = (int)Parent(vid); if (parentId != -1) { children[parentId].Remove(vid); parent.Remove(vid); } // Remove children edges foreach (int child in Children(vid)) { parent[child] = -1; } if (children.ContainsKey(vid)) { children.Remove(vid); } } SetRoot(vertexId); return(this); } else { Dictionary <int, int> renumberedTree = new Dictionary <int, int>(); PropertyTree tree = new PropertyTree(); SetRoot(0); foreach (string name in Properties().Keys) { tree.AddProperty(name); } renumberedTree.Add(vertexId, tree.root); tree.AddVertexProperties(tree.root, GetVertexProperties(vertexId)); IEnumerable <int> subTree = t.RecursivePreOrder((mtg)this, vertexId); foreach (int vid in subTree) { if (vid != vertexId) { int parentId = (int)Parent(vid); if (parentId != -1) { int parent = renumberedTree[parentId]; int v = tree.AddChild(parent); renumberedTree.Add(vid, v); } tree.AddVertexProperties(vid, GetVertexProperties(vid)); } } return(tree); } }