public List <SimpleTreeNode <T> > FindNodesByValue(T val)
{
// ваш код поиска узлов по значению
List <SimpleTreeNode <T> > returnList = new List <SimpleTreeNode <T> >();
Stack <SimpleTreeNode <T> > stack = new Stack <SimpleTreeNode <T> >();
SimpleTreeNode <T> Node = Root;
stack.Push(Root);
while (stack.Count > 0)
{
if (Node.Children != null)
{
foreach (SimpleTreeNode <T> node in Node.Children)
{
stack.Push(node);
}
}
Node = stack.Pop();
if (Comparer <T> .Default.Compare(Node.NodeValue, val) == 0)
{
returnList.Add(Node);
}
}
return(returnList);
}
public void MoveNode(SimpleTreeNode <T> OriginalNode, SimpleTreeNode <T> NewParent)
{
// ваш код перемещения узла вместе с его поддеревом --
// в качестве дочернего для узла NewParent
if (Root != null)
{
SimpleTreeNode <T> OldParent;
List <SimpleTreeNode <T> > AllNodes = GetAllNodes();
foreach (SimpleTreeNode <T> node in AllNodes)
{
if (node == OriginalNode)
{
OldParent = node.Parent;
node.Parent = NewParent;
AddChild(NewParent, node);
OldParent.Children.Remove(node);
if (OldParent.Children.Count == 0)
{
OldParent.Children = null;
}
return;
}
}
}
}
private List <SimpleTreeNode <T> > Recursive(SimpleTreeNode <T> targetNode, T val = default(T), bool isFind = false)
{
SimpleTreeNode <T> node = targetNode;
var result = new List <SimpleTreeNode <T> > {
node
};
if (isFind)
{
result = new List <SimpleTreeNode <T> >();
if (node.NodeValue.Equals(val))
{
result.Add(node);
}
}
for (int i = 0; node.Children != null && i < node.Children.Count; i++)
{
if (isFind)
{
result.AddRange(Recursive(node.Children[i], val, true));
}
else
{
result.AddRange(Recursive(node.Children[i]));
}
}
return(result);
}
private static void CalcLevel(SimpleTreeNode <T> node)
{
var count = 0;
CalcLevel(node, ref count);
node.Level = count;
}
public int LeafCount()
{
// количество листьев в дереве
int count = 0;
Stack <SimpleTreeNode <T> > stack = new Stack <SimpleTreeNode <T> >();
SimpleTreeNode <T> Node = Root;
stack.Push(Root);
while (stack.Count > 0)
{
if (Node.Children != null)
{
foreach (SimpleTreeNode <T> node in Node.Children)
{
stack.Push(node);
}
}
else
{
count++;
}
Node = stack.Pop();
}
return(count);
}
public void TestInitialize()
{
Node0 = new SimpleTreeNode <int>(777, null);
Tree = new SimpleTree <int>(Node0);
Node1 = new SimpleTreeNode <int>(10, null);
Node2 = new SimpleTreeNode <int>(20, null);
Node3 = new SimpleTreeNode <int>(30, null);
Node4 = new SimpleTreeNode <int>(40, null);
Node5 = new SimpleTreeNode <int>(50, null);
Node6 = new SimpleTreeNode <int>(60, null);
Node7 = new SimpleTreeNode <int>(70, null);
Node8 = new SimpleTreeNode <int>(80, null);
Node9 = new SimpleTreeNode <int>(90, null);
Node10 = new SimpleTreeNode <int>(60, null);
Tree.AddChild(Node0, Node1);
Tree.AddChild(Node1, Node2);
Tree.AddChild(Node1, Node7);
Tree.AddChild(Node2, Node3);
Tree.AddChild(Node2, Node5);
Tree.AddChild(Node1, Node4);
Tree.AddChild(Node3, Node8);
Tree.AddChild(Node3, Node9);
Tree.AddChild(Node9, Node10);
Tree.AddChild(Node9, Node6);
}
// Удаляет ребро связывающее текущий узел(вершину) со своим родителем.
//
private void DeleteEdge(SimpleTreeNode <T> node)
{
if (node.Parent != null)
{
node.Parent.Children.Remove(node);
node.Parent = null;
}
}
private static void CalcLevel(SimpleTreeNode <T> node, ref int count)
{
count += 1;
if (node.Parent == null)
{
return;
}
CalcLevel(node.Parent, ref count);
}
public void AddChild(SimpleTreeNode <T> ParentNode, SimpleTreeNode <T> NewChild)
{
// ваш код добавления нового дочернего узла существующему ParentNode
NewChild.Parent = ParentNode;
if (ParentNode.Children == null)
{
ParentNode.Children = new List <SimpleTreeNode <T> >();
}
ParentNode.Children.Add(NewChild);
}
public void MoveNode(SimpleTreeNode <T> OriginalNode, SimpleTreeNode <T> NewParent)
{
// ваш код перемещения узла вместе с его поддеревом --
// в качестве дочернего для узла NewParent
if (OriginalNode != NewParent)
{
SimpleTreeNode <T> node = OriginalNode;
OriginalNode.Parent.Children.Remove(OriginalNode);
AddChild(NewParent, node);
}
}
private void WriteNextLayer(SimpleTreeNode <T> node)
{
if (node.Children != null)
{
foreach (SimpleTreeNode <T> child in node.Children)
{
child.layer = node.layer + 1;
WriteNextLayer(child);
}
}
}
private void SetNextLevel(SimpleTreeNode <T> node)
{
if (node.Children != null)
{
foreach (SimpleTreeNode <T> child in node.Children)
{
child.level = node.level + 1;
SetNextLevel(child);
}
}
}
private static void LeafResult(SimpleTreeNode <T> node, ref int counter)
{
if (node.Children == null)
{
counter += 1;
return;
}
foreach (var nodeChild in node.Children)
{
LeafResult(nodeChild, ref counter);
}
}
private static void EnumerateAndCalcTree(SimpleTreeNode <T> node)
{
CalcLevel(node);
if (node.Children == null)
{
return;
}
foreach (var nodeChild in node.Children)
{
EnumerateAndCalcTree(nodeChild);
}
}
private static void FillResult(SimpleTreeNode <T> node, List <SimpleTreeNode <T> > result)
{
result.Add(node);
if (node.Children == null)
{
return;
}
foreach (var nodeChild in node.Children)
{
FillResult(nodeChild, result);
}
}
public List <SimpleTreeNode <T> > GetChildren(SimpleTreeNode <T> Node)
{
List <SimpleTreeNode <T> > Children = new List <SimpleTreeNode <T> >();
if (Node.Children != null)
{
foreach (SimpleTreeNode <T> node in Node.Children)
{
Children.Add(node);
Children.AddRange(GetChildren(node));
}
}
return(Children);
}
private void FindResult(SimpleTreeNode <T> node, List <SimpleTreeNode <T> > result, T val)
{
if (val.Equals(node.NodeValue))
{
result.Add(node);
}
if (node.Children == null)
{
return;
}
foreach (var nodeChild in node.Children)
{
FindResult(nodeChild, result, val);
}
}
public void DeleteNode(SimpleTreeNode <T> NodeToDelete) // код удаления существующего узла NodeToDelete
{
if (NodeToDelete.Parent == null)
{
Root = null;
}
else if (NodeToDelete.Parent.Children.Count == 1)
{
NodeToDelete.Parent.Children = null;
}
else
{
NodeToDelete.Parent.Children.Remove(NodeToDelete);
}
}
public void DeleteNode(SimpleTreeNode <T> NodeToDelete)
{
if (NodeToDelete.Parent == null)
{
Root = null;
}
else if (NodeToDelete.Parent.Children.Count == 1)
{
NodeToDelete.Parent.Children = null;
}
else
{
NodeToDelete.Parent.Children.Remove(NodeToDelete);
}
}
public void MoveNode(SimpleTreeNode <T> OriginalNode, SimpleTreeNode <T> NewParent)
{
// ваш код перемещения узла вместе с его поддеревом --
// в качестве дочернего для узла NewParent
if (NewParent.Children == null)
{
NewParent.Children = new List <SimpleTreeNode <T> >();
}
NewParent.Children.Add(OriginalNode);
if (OriginalNode.Parent != null)
{
OriginalNode.Parent.Children.Remove(OriginalNode);
}
OriginalNode.Parent = NewParent;
}
private List <SimpleTreeNode <T> > AllNodes(List <SimpleTreeNode <T> > list, SimpleTreeNode <T> node)
{
list.Add(node);
if (node.Children != null)
{
foreach (SimpleTreeNode <T> child in node.Children)
{
list = AllNodes(list, child);
}
}
if (list.Count > 0)
{
return(list);
}
return(null);
}
public void MoveNode(SimpleTreeNode <T> OriginalNode, SimpleTreeNode <T> NewParent)
{
List <SimpleTreeNode <T> > targetList = FindNodesByValue(OriginalNode.NodeValue);
List <SimpleTreeNode <T> > newParentList = FindNodesByValue(NewParent.NodeValue);
if (targetList != null && newParentList != null)
{
var targetNode = targetList.Find(delegate(SimpleTreeNode <T> node) { return(node == OriginalNode); });
var newParentNode = newParentList.Find(delegate(SimpleTreeNode <T> node) { return(node == NewParent); });
if (targetNode != null && targetNode != Root && newParentNode != null)
{
OriginalNode.Parent.Children.Remove(OriginalNode);
OriginalNode.Parent = NewParent;
AddChild(NewParent, OriginalNode);
}
}
}
public void AddChild(SimpleTreeNode <T> ParentNode, SimpleTreeNode <T> NewChild) // код добавления нового дочернего узла существующему ParentNode
{
if (Root == null)
{
Root = NewChild;
Root.layer = 1;
}
else
{
if (ParentNode.Children == null)
{
ParentNode.Children = new List <SimpleTreeNode <T> >();
}
ParentNode.Children.Add(NewChild);
NewChild.Parent = ParentNode;
NewChild.layer = NewChild.Parent.layer + 1;
}
}
public void AddChild(SimpleTreeNode <T> ParentNode, SimpleTreeNode <T> NewChild)
{
if (Root == null)
{
Root = NewChild;
Root.level = 1;
}
else
{
if (ParentNode.Children == null)
{
ParentNode.Children = new List <SimpleTreeNode <T> >();
}
ParentNode.Children.Add(NewChild);
NewChild.Parent = ParentNode;
NewChild.level = NewChild.Parent.level + 1;
}
}
public void DeleteNode(SimpleTreeNode <T> NodeToDelete)
{
// ваш код удаления существующего узла NodeToDelete
if (NodeToDelete.Parent != null)
{
NodeToDelete.Parent.Children.Remove(NodeToDelete);
if (NodeToDelete.Parent.Children.Count == 0)
{
NodeToDelete.Parent.Children = null;
}
NodeToDelete.Children = null;
NodeToDelete.Parent = null;
}
else
{
return;
}
}
public List <int> EvenTrees()
{
if (Count() % 2 == 1)
{
return(new List <int>()); // при нечетном количестве возвращаем пустой список
}
// список листов
List <SimpleTreeNode <T> > leafs = Recursive(Root).FindAll(
delegate(SimpleTreeNode <T> node) { return(node.Children == null || node.Children.Count == 0); });
List <int> edges = new List <int>(); // создаем список связей
SimpleTreeNode <T> previousLeafParrent = null; // используется для исключения повторного обхода от листьев с общим родителем
foreach (var leaf in leafs)
{
if (previousLeafParrent != leaf.Parent) // пропуск обхода от листов - соседей
{
SimpleTreeNode <T> node = leaf.Parent; // проход от каждого листа
while (node != Root)
{
int nodesCount = Recursive(node).Count; // считать количество узлов узла
if (nodesCount % 2 == 0) // при чётном числе узлов сохраняем связь узла и его родителя в список
{
if (typeof(T) == typeof(int))
{
// проверка, содержится ли такая связь в списке
if (!edges.Contains(Convert.ToInt32(node.Parent.NodeValue)) ||
!edges.Contains(Convert.ToInt32(node.NodeValue)))
{
edges.Add(Convert.ToInt32(node.Parent.NodeValue));
edges.Add(Convert.ToInt32(node.NodeValue));
}
}
}
node = node.Parent; // переход к корню
}
}
previousLeafParrent = leaf.Parent;
}
return(edges);
}
private int MarkEdges(List <T> forest, SimpleTreeNode <T> node)
{
int count = 1;
if (node.Children == null)
{
return(count);
}
foreach (SimpleTreeNode <T> n in node.Children)
{
count += MarkEdges(forest, n);
}
if (count % 2 == 0 && node.Parent != null)
{
forest.Add(node.Parent.NodeValue);
forest.Add(node.NodeValue);
count = 0;
}
return(count);
}
public void DeleteNode(SimpleTreeNode <T> NodeToDelete)
{
// ваш код удаления существующего узла NodeToDelete
SimpleTreeNode <T> ParentRemChild;
List <SimpleTreeNode <T> > RootChildren = GetChildren(Root);
foreach (SimpleTreeNode <T> node in RootChildren)
{
if (node == NodeToDelete)
{
ParentRemChild = node.Parent;
ParentRemChild.Children.Remove(node);
if (ParentRemChild.Children.Count == 0)
{
ParentRemChild.Children = null;
}
return;
}
}
}
public void AddChild()
{
Node11 = new SimpleTreeNode <int>(110, null);
Node12 = new SimpleTreeNode <int>(120, null);
// 1 child was added
Tree.AddChild(Node0, Node11);
Assert.AreEqual(777, Tree.Root.NodeValue);
Assert.AreEqual(2, Tree.Root.Children.Count);
Assert.AreEqual(Node0, Tree.Root.Children[0].Parent);
Assert.AreEqual(12, Tree.Count());
// 2 children were added
Tree.AddChild(Node1, Node12);
Assert.AreEqual(10, Tree.Root.Children[0].NodeValue);
Assert.AreEqual(4, Tree.Root.Children[0].Children.Count);
Assert.AreEqual(Node1, Tree.Root.Children[0].Children[0].Parent);
Assert.AreEqual(120, Tree.Root.Children[0].Children[3].NodeValue);
Assert.AreEqual(13, Tree.Count());
}
public void AddChild(SimpleTreeNode <T> ParentNode, SimpleTreeNode <T> NewChild)
{
if (FindNodesByValue(ParentNode.NodeValue) != null)
{
SimpleTreeNode <T> targetNode = FindNodesByValue(ParentNode.NodeValue)[0]; // берём первый узел, если узлов с таким значением в дереве несколько
if (targetNode.Children == null)
{
targetNode.Children = new List <SimpleTreeNode <T> > {
NewChild
}
}
;
else
{
targetNode.Children.Add(NewChild);
}
NewChild.Parent = targetNode;
}
}
