Merge pull request #46 from Valdas3/narytree

#36: implement n-ary tree

Author: realwoopee

Algorithms/Algorithms.Tests/NTreeTests/NTreeTests.cs

@@ -0,0 +1,95 @@
+using System;
+using Algorithms.NTree;
+using Xunit;
+
+namespace Algorithms.Tests.NTreeTests
+{
+    public class NTreeTests
+    {
+        NTree<int> BuildTree()
+        {
+            var tree = new NTree<int>(0);
+            tree.Add(1).Add(2).Add(3);
+                tree.Children[0].Add(4).Add(5);
+                    tree.Children[0].Children[0].Add(6);
+                tree.Children[1].Add(7);
+                tree.Children[2].Add(8);
+                    tree.Children[2].Children[0].Add(9);
+            return tree;
+        }
+
+        [Fact]
+        public void ElementsAreInsertedInCorrectOrder()
+        {
+            var tree = BuildTree();
+
+            var result = tree.ToString();
+
+            Assert.Equal("0146527389", result);
+        }
+
+        [Fact]
+        public void ParentReturnsCorrectNode()
+        {
+            var tree = BuildTree();
+            var child = tree.Children[1].Children[0];
+            var parent = tree.Children[1];
+
+            var result = child.Parent;
+
+            Assert.Equal(parent.Value, result.Value);
+        }
+
+        [Fact]
+        public void ParentOfRootIsNull()
+        {
+            var tree = BuildTree();
+
+            Assert.Null(tree.Parent);
+        }
+
+        [Fact]
+        public void FindReturnsCorrectNode()
+        {
+            var tree = BuildTree();
+            var expected = tree.Children[0].Children[0];
+
+            var result = tree.Find(4);
+
+            Assert.Same(expected, result);
+        }
+
+        [Fact]
+        public void FindReturnsNullWhenValueDoesNotExist()
+        {
+            var tree = BuildTree();
+
+            var result = tree.Find(-14);
+
+            Assert.Null(result);
+        }
+
+        [Theory]
+        [InlineData(1, "027389")]
+        [InlineData(2, "01465389")]
+        [InlineData(9, "014652738")]
+        public void RemoveWorks(int node, string expected)
+        {
+            var tree = BuildTree();
+            var nodeToRemove = tree.Find(node);
+
+            nodeToRemove.Remove();
+
+            Assert.Equal(expected, tree.ToString());
+        }
+
+        [Fact]
+        public void ThrowsExceptionWhenRemovingRoot()
+        {
+            var tree = BuildTree();
+            Action removeRoot = () => tree.Remove();
+
+            Assert.Throws<ArgumentException>(removeRoot);
+        }
+    }
+}

Algorithms/Algorithms/NTree/NTree.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Algorithms.NTree
+{
+    public class NTree<T> where T : IEquatable<T>
+    {
+        public T Value { get; set; }
+        public NTree<T> Parent { get; set; }
+        public List<NTree<T>> Children { get; set; } = new List<NTree<T>>();
+
+        public NTree(T value)
+        {
+            Value = value;
+        }
+
+        public NTree<T> Add(T value)
+        {
+            var child = new NTree<T>(value)
+            {
+                Parent = this
+            };
+            Children.Add(child);
+            return this;
+        }
+
+        public NTree<T> Find(T value)
+        {
+            if (Value.Equals(value))
+            {
+                return this;
+            }
+
+            return Children.Select(x => x.Find(value)).FirstOrDefault(x => x != null);
+        }
+
+        public void Remove()
+        {
+            if (Parent == null)
+            {
+                throw new ArgumentException("Can't remove root");
+            }
+
+            var index = Parent.Children.FindIndex(x => x.Value.Equals(Value));
+            Parent.Children.RemoveAt(index);
+        }
+
+        // returns concatenated values in prefix order
+        public override string ToString()
+        {
+            return Value + string.Concat(Children.Select(x => x.ToString()));
+        }
+    }
+}