static void Main(string[] args)
{
DirectoryInfo dir = new DirectoryInfo("../..");
Folder fold = new Folder(dir.Name, null, null);
Tree<Folder> folders = new Tree<Folder>(fold);
DirectoryTraversal(folders, dir);
}
static Tree<int> GetTreeNodeByValue(int value)
{
if (! nodeByValue.ContainsKey(value))
{
nodeByValue[value] = new Tree<int>(value);
}
return nodeByValue[value];
}
public static Tree GetTreeNodeByValue(int value)
{
if (!NodeByValue.ContainsKey(value))
{
NodeByValue[value] = new Tree(value);
}
return NodeByValue[value];
}
private static void FindMiddleNodes(List<int> middleNodes, Tree<int> node)
{
if (node.Children.Count != 0 && node.Parent != null)
{
middleNodes.Add(node.Value);
}
foreach (var child in node.Children)
{
FindMiddleNodes(middleNodes, child);
}
}
private static void FindLeafNodes(List<int> leafNodes, Tree<int> node)
{
if (node.Children.Count == 0)
{
leafNodes.Add(node.Value);
}
foreach (var child in node.Children)
{
FindLeafNodes(leafNodes, child);
}
}
private static void FindLongestPath(Tree<int> node, int currentDepth)
{
int depth = currentDepth;
if (depth > longestPath && node.Children.Count == 0)
{
longestPath = depth;
longestPathLeaf = node;
}
foreach (var child in node.Children)
{
FindLongestPath(child, depth + 1);
}
}
private static void FindAllPaths(Tree<int> node, int sum)
{
tempPath.Push(node);
foreach (var child in node.Children)
{
FindAllPaths(child, sum);
}
int tempPathSum = tempPath.Sum(n => n.Value);
if (tempPathSum == sum)
{
var foundPath = tempPath.ToList();
foundPath.Reverse();
pathsWithGivenSum.Add(foundPath);
}
tempPath.Pop();
}
private static void Main(string[] args)
{
Tree<int> testTree = new Tree<int>();
int nodeCount = int.Parse(Console.ReadLine());
for (int node = 1; node < nodeCount; node++)
{
string[] edge = Console.ReadLine().Split();
int parentValue = int.Parse(edge[0]);
int childValue = int.Parse(edge[1]);
testTree.MakeConnectionNodes(parentValue, childValue);
}
int pathSum = int.Parse(Console.ReadLine());
TreeTraverseUtils.PrintTree(testTree.Nodes);
TreeTraverseUtils.GetLongestPathInTree(testTree.RooTNode);
TreeTraverseUtils.GetPathWithGivenSum(testTree.RooTNode, pathSum);
}
private static void FindAllPathsWithGiveSum(Tree<int> node, int sum, int currentSum)
{
currentSum += node.Value;
if (currentSum == sum)
{
PrintPathFoSum(node, sum);
}
if (currentSum > sum)
{
return;
}
foreach (var child in node.Children)
{
FindAllPathsWithGiveSum(child, sum, currentSum);
}
}
public static void DirectoryTraversal(Tree<Folder> folder, DirectoryInfo dir)
{
File[] files = new File[dir.GetFiles().Length];
FileInfo[] filesInfo = dir.GetFiles();
for (int i = 0; i < filesInfo.Length; i++)
{
files[i] = new File(filesInfo[i].Name, filesInfo[i].Length);
}
folder.Value.Files = files;
List<Folder> childFolders = new List<Folder>();
foreach (var directory in dir.GetDirectories())
{
Folder fold = new Folder(directory.Name, null, null);
Tree<Folder> node = new Tree<Folder>(fold);
DirectoryTraversal(node, directory);
folder.Children.Add(node);
childFolders.Add(fold);
node.Parent = folder;
}
folder.Value.ChildFolders = childFolders.ToArray();
}
private static List<Tree<int>> FindTheLongestPath(Tree<int> rootNode)
{
List<Tree<int>> path = new List<Tree<int>>();
foreach (var child in rootNode.Children)
{
List<Tree<int>> tempPath = FindTheLongestPath(child);
if (tempPath.Count > path.Count)
{
path = tempPath;
}
}
path.Insert(0, rootNode);
return path;
}
private static void FindSubtree(List<int> subtree, Tree<int> node)
{
subtree.Add(node.Value);
if (subtree.Sum() == subtreeSum)
{
Console.WriteLine("{0}", string.Join(" + ", subtree));
return;
}
if (node.Parent != null)
{
foreach (var child in node.Children)
{
FindSubtree(subtree, child);
}
}
}
private static void PrintPathFoSum(Tree<int> node, int sum)
{
int currentSum = 0;
Tree<int> currentNode = node;
Stack<int> path = new Stack<int>();
while (currentSum < sum)
{
path.Push(currentNode.Value);
currentSum += currentNode.Value;
currentNode = currentNode.Parent;
}
Console.WriteLine(string.Join(" -> ", path));
}
static IList<Tree<int>> FindLongestPath(Tree<int> treeNode)
{
IList<Tree<int>> longestPath = new List<Tree<int>>();
foreach (var childNode in treeNode.Children)
{
var currentPath = FindLongestPath(childNode);
if (currentPath.Count > longestPath.Count)
{
longestPath = currentPath;
}
}
longestPath.Add(treeNode);
return longestPath;
}
static List<Tree<int>> FindSubtreesWithSum(Tree<int> root, int targetSum)
{
var results = new List<Tree<int>>();
var currentSum = FindTreeSum(root);
if (currentSum == targetSum)
{
results.Add(root);
}
foreach (var child in root.Children)
{
results.AddRange(FindSubtreesWithSum(child, targetSum));
}
return results;
}
static int FindTreeSum(Tree<int> node)
{
int sum = node.Value;
foreach (var child in node.Children)
{
sum += FindTreeSum(child);
}
return sum;
}
