public TreeOfNodes <T> Remove(T element)
        {
            TreeOfNodes <T> removedElement = null;

            for (int i = 0; i < this.descendants.Count; i++)
            {
                if (this.descendants[i].Value.Equals(element))
                {
                    removedElement = this.descendants[i];
                    this.descendants.RemoveAt(i);
                    this.size--;
                    break;
                }
                else if (this.descendants[i].Size > 1)
                {
                    removedElement = this.descendants[i].Remove(element);
                    if (removedElement != null)
                    {
                        this.size--;
                        break;
                    }
                }
            }

            return(removedElement);
        }
        public static IList <TreeOfNodes <T> > CalculateLongestPath <T>(TreeOfNodes <T> tree)
            where T : IComparable <T>
        {
            List <TreeOfNodes <T> > chain = new List <TreeOfNodes <T> >();

            chain.Add(tree);

            if (tree.Size > 1)
            {
                List <TreeOfNodes <T> > subChain = new List <TreeOfNodes <T> >();
                foreach (TreeOfNodes <T> descendant in tree.DirectDescendants)
                {
                    List <TreeOfNodes <T> > descendantChain =
                        new List <TreeOfNodes <T> >(CalculateLongestPath(descendant));

                    if (descendantChain.Count > subChain.Count)
                    {
                        subChain = descendantChain;
                    }
                }

                chain.AddRange(subChain);
            }

            return(chain);
        }
        public TreeOfNodes <T> Add(TreeOfNodes <T> tree)
        {
            if (this.Size > 0)
            {
                tree.Parent = this;
                this.descendants.Add(tree);
                this.size++;
            }

            return(tree);
        }
Exemplo n.º 4
0
        private static Queue <TreeOfNodes <T> > ParseUserInput <T>(T template, char[] splitChars)
            where T : IComparable <T>
        {
            try
            {
                Clipboard.SetText(File.ReadAllText("sampleInput.txt"));
                helper.ConsoleMio.WriteLine(
                    "You can paste the sample input copied to your clipboard", ConsoleColor.DarkRed);
            }
            catch (IOException)
            {
            }

            Queue <TreeOfNodes <T> > createdNodes = new Queue <TreeOfNodes <T> >();
            HashSet <T> distinctNodes             = new HashSet <T>();

            helper.ConsoleMio.Write("Enter total count of nodes N = ", ConsoleColor.DarkRed);
            int remainingNodes = int.Parse(helper.ConsoleMio.ReadInColor(ConsoleColor.DarkBlue));

            while (remainingNodes > 0)
            {
                helper.ConsoleMio.Write(
                    "Remaining Nodes(Repeating nodes are exluded): ",
                    ConsoleColor.DarkCyan);
                helper.ConsoleMio.WriteLine(remainingNodes.ToString(), ConsoleColor.DarkRed);

                helper.ConsoleMio.Write("Enter a sequence of nodes (first will be root): ", ConsoleColor.DarkCyan);

                int newNodesCount;
                T[] nodesToBe = GetNodesToBe(splitChars, distinctNodes, out newNodesCount);

                if (newNodesCount > remainingNodes)
                {
                    throw new ApplicationException(
                              nodesToBe.Length +
                              " Nodes were entered, but there is only space for " + remainingNodes +
                              " nodes");
                }

                remainingNodes -= newNodesCount;

                var rootNode = new TreeOfNodes <T>(nodesToBe[0]);
                for (int i = 1; i < nodesToBe.Length; i++)
                {
                    rootNode.Add(nodesToBe[i]);
                }

                createdNodes.Enqueue(rootNode);
            }

            return(createdNodes);
        }
        public static IList <TreeOfNodes <T> > GetLeafNodes <T>(TreeOfNodes <T> tree)
            where T : IComparable <T>
        {
            List <TreeOfNodes <T> > leafs = new List <TreeOfNodes <T> >();

            if (tree.Size > 1)
            {
                foreach (TreeOfNodes <T> descendant in tree.DirectDescendants)
                {
                    leafs.AddRange(GetLeafNodes <T>(descendant));
                }
            }
            else
            {
                leafs.Add(tree);
            }

            return(leafs);
        }
        public TreeOfNodes <T> Add(T element)
        {
            TreeOfNodes <T> result;

            if (this.size == 0)
            {
                this.Value = element;
                result     = this;
            }
            else
            {
                result = new TreeOfNodes <T>(element)
                {
                    parent = this
                };

                this.descendants.Add(result);
            }

            this.size++;

            return(result);
        }
        public static IList <TreeOfNodes <T> > GetMiddleNodes <T>(TreeOfNodes <T> tree)
            where T : IComparable <T>
        {
            List <TreeOfNodes <T> > middleNodes = new List <TreeOfNodes <T> >();

            if (tree.Parent != null && tree.Size > 1)
            {
                middleNodes.Add(tree);
            }
            else if (tree.Size > 1)
            {
                foreach (TreeOfNodes <T> descendant in tree.DirectDescendants)
                {
                    IList <TreeOfNodes <T> > descendantMiddleNodes = GetMiddleNodes(descendant);
                    if (descendantMiddleNodes.Count > 0)
                    {
                        middleNodes.AddRange(descendantMiddleNodes);
                    }
                }
            }

            return(middleNodes);
        }
        public static TreeOfNodes <T> AssociateNodes <T>(Queue <TreeOfNodes <T> > availableNodes)
            where T : IComparable <T>
        {
            TreeOfNodes <T> rootTree = availableNodes.Dequeue();

            // Max possible itreations if there are unmached elements at this point
            // They will never match so brake the loop
            int remainingIterations = availableNodes.Count * availableNodes.Count;

            while (availableNodes.Count > 0 && remainingIterations > 0)
            {
                TreeOfNodes <T> tree = availableNodes.Dequeue();

                TreeOfNodes <T> parent = rootTree.Contains(tree.Value);
                if (parent != null)
                {
                    parent.AddMany(tree.DirectDescendants);
                }
                else
                {
                    parent = tree.Contains(rootTree.Value);
                    if (parent != null)
                    {
                        parent.AddMany(rootTree.DirectDescendants);
                        rootTree = tree;
                    }
                    else
                    {
                        availableNodes.Enqueue(tree);
                    }
                }

                remainingIterations--;
            }

            return(rootTree);
        }
        /// <summary>
        /// Attempts to find the given value in all tree nodes (including self)
        /// </summary>
        /// <param name="element">The searched element</param>
        /// <returns>
        /// Returns The TreeNode which value is equal to <paramref name="element"/> or null if
        /// it doesn't exist
        /// </returns>
        public TreeOfNodes <T> Contains(T element)
        {
            if (this.Value.Equals(element))
            {
                return(this);
            }
            else if (this.descendants.Count > 0)
            {
                foreach (TreeOfNodes <T> descendant in this.descendants)
                {
                    TreeOfNodes <T> result = descendant.Contains(element);
                    if (result != null)
                    {
                        return(result);
                    }
                }

                return(null);
            }
            else
            {
                return(null);
            }
        }
Exemplo n.º 10
0
        private static void Main()
        {
            helper.ConsoleMio.Setup();

            helper.ConsoleMio.PrintHeading("Task 1 Tree Of N Nodes");

            Queue <TreeOfNodes <int> > availableNodes = ParseUserInput(
                template: 0, splitChars: new[] { ' ' });

            TreeOfNodes <int> tree = TreeProcessing.AssociateNodes(availableNodes);

            Console.WriteLine();
            helper.ConsoleMio.WriteLine("Nodes Structure\n{node} -> {subNodes}", ConsoleColor.DarkBlue);
            Console.WriteLine(tree.ToString());

            helper.ConsoleMio.WriteLine("Root Node: {0}", ConsoleColor.DarkGreen, tree.Value);

            IList <TreeOfNodes <int> > leafNodes = TreeProcessing.GetLeafNodes(tree);

            helper.ConsoleMio.WriteLine(
                "Leaf Nodes: {0}", ConsoleColor.DarkGreen, string.Join(", ", leafNodes));

            IList <TreeOfNodes <int> > middleNodes = TreeProcessing.GetMiddleNodes(tree);

            helper.ConsoleMio.WriteLine(
                "Middle Nodes: {0}",
                ConsoleColor.DarkGreen,
                string.Join(", ", middleNodes.Select(n => n.Value)));

            IList <TreeOfNodes <int> > longestPath = TreeProcessing.CalculateLongestPath(tree);

            helper.ConsoleMio.WriteLine(
                "Longest Path: {0}",
                ConsoleColor.DarkGreen,
                string.Join(" -> ", longestPath.Select(n => n.Value)));
        }
 public TreeOfNodes(TreeOfNodes <T> parent)
     : this()
 {
     this.parent = parent;
 }