Merge remote-tracking branch 'upstream/master'

Author: Gutsonok

.gitignore

@@ -190,3 +190,6 @@ _Pvt_Extensions/
 ModelManifest.xml
 .vs/
 .idea/
+
+# Local test runner
+testrunner

.travis.yml

@@ -1,10 +1,10 @@
 language: csharp
-solution: C-Sharp-Algorithms.sln
-dotnet: 2.0.3
 mono: none
-dist: trusty
+dotnet: 2.1.502
+solution: C-Sharp-Algorithms.sln
 install:
   - dotnet restore
 script:
-  - dotnet build
-  - dotnet test UnitTest/UnitTest.csproj
+  - dotnet msbuild /p:Configuration=Release C-Sharp-Algorithms.sln
+  - dotnet restore
+  - dotnet test UnitTest/UnitTest.csproj

Algorithms/Algorithms.csproj

@@ -3,10 +3,6 @@
     <TargetFramework>netcoreapp2.0</TargetFramework>
   </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="xunit" Version="2.4.0" />
-  </ItemGroup>
-
   <ItemGroup>
     <ProjectReference Include="..\DataStructures\DataStructures.csproj" />
   </ItemGroup>

Algorithms/Graphs/BellmanFordShortestPaths.cs

@@ -35,21 +35,23 @@ public class BellmanFordShortestPaths<TGraph, TVertex>
         /// </summary>
         public BellmanFordShortestPaths(TGraph Graph, TVertex Source)
         {
-            if (Graph == null)
-                throw new ArgumentNullException();
-            if (!Graph.HasVertex(Source))
-                throw new ArgumentException("The source vertex doesn't belong to graph.");
+            if (Graph == null) {
+                throw new ArgumentNullException ();
+            } else {
+                if (!Graph.HasVertex (Source))
+                    throw new ArgumentException ("The source vertex doesn't belong to graph.");
 
-            // Init
-            _initializeDataMembers(Graph);
+                // Init
+                _initializeDataMembers (Graph);
 
-            // Traverse the graph
-            var status = _bellmanFord(Graph, Source);
+                // Traverse the graph
+                var status = _bellmanFord (Graph, Source);
 
-            if (status == false)
-                throw new Exception("Negative-weight cycle detected.");
+                if (status == false)
+                    throw new Exception ("Negative-weight cycle detected.");
 
-            Debug.Assert(_checkOptimalityConditions(Graph, Source));
+                Debug.Assert (_checkOptimalityConditions (Graph, Source));
+            }
         }
 
 

DataStructures/DataStructures.csproj

@@ -3,10 +3,6 @@
     <TargetFramework>netcoreapp2.0</TargetFramework>
   </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="xunit" Version="2.4.0" />
-  </ItemGroup>
-  
   <ItemGroup>
     <Content Include="Data\PrimesDocument_10K.csv">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>

DataStructures/Trees/TernarySearchTree.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace DataStructures.Trees
+{
+    public class TernarySearchTree
+    {
+        public TernaryTreeNode Root { get; private set; }
+
+        public void Insert(string word)
+        {
+            if (string.IsNullOrWhiteSpace(word))
+                throw new Exception("Inputted value is empty");
+
+            if (Root == null)
+                Root = new TernaryTreeNode(null, word[0], word.Length == 1);
+
+            WordInsertion(word);
+        }
+
+        public void Insert(string[] words)
+        {
+            foreach (var word in words)
+            {
+                Insert(word);
+            }
+        }
+
+        void WordInsertion(string word)
+        {
+            int index = 0;
+            TernaryTreeNode currentNode = Root;
+
+            while (index < word.Length)
+                currentNode = ChooseNode(currentNode, word, ref index);
+        }
+
+        TernaryTreeNode ChooseNode(TernaryTreeNode currentNode, string word, ref int index)
+        {
+            //Center Branch
+            if (word[index] == currentNode.Value)
+            {
+                index++;
+
+                if (currentNode.GetMiddleChild == null)
+                    InsertInTree(currentNode.AddMiddleChild(word[index], word.Length == index + 1), word, ref index);
+                
+
+                return currentNode.GetMiddleChild;
+            }
+            //Right Branch
+            else if (word[index] > currentNode.Value)
+            {
+                if (currentNode.GetRightChild == null)
+                    InsertInTree(currentNode.AddRightChild(word[index], word.Length == index + 1), word, ref index);
+
+                return currentNode.GetRightChild;
+            }
+            //Left Branch
+            else
+            {
+                if (currentNode.GetLeftChild == null)
+                    InsertInTree(currentNode.AddLeftChild(word[index], word.Length == index + 1), word, ref index);
+
+                return currentNode.GetLeftChild;
+            }
+        }
+
+        void InsertInTree(TernaryTreeNode currentNode, string word, ref int currentIndex)
+        {
+            int length = word.Length;
+
+            currentIndex++;
+            var currNode = currentNode;
+            for (int i = currentIndex; i < length; i++)
+                currNode = currNode.AddMiddleChild(word[i], word.Length == currentIndex + 1);
+
+            currentIndex = length;
+        }
+    }
+}

DataStructures/Trees/TernaryTreeNode.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace DataStructures.Trees
+{
+    public class TernaryTreeNode
+    {
+        public virtual TernaryTreeNode Parent { get; private set; }
+        protected virtual TernaryTreeNode[] childs { get; set; }
+
+        public virtual TernaryTreeNode GetLeftChild { get { return childs[0]; } }
+        public virtual TernaryTreeNode GetMiddleChild { get { return childs[1]; } }
+        public virtual TernaryTreeNode GetRightChild { get { return childs[2]; } }
+
+        public virtual bool FinalLetter { get; set; }
+        public virtual char Value { get; set; }
+
+        public TernaryTreeNode(TernaryTreeNode parent)
+        {
+            this.Parent = parent;
+            childs = new TernaryTreeNode[3];
+        }
+
+        public TernaryTreeNode(TernaryTreeNode parent, char value, bool isFinal)
+        {
+            this.Parent = parent;
+            this.Value = value;
+            this.FinalLetter = isFinal;
+            childs = new TernaryTreeNode[3];
+        }
+
+        public virtual TernaryTreeNode AddLeftChild(char value, bool isFinal)
+        {
+            childs[0] = new TernaryTreeNode(this, value, isFinal);
+            return childs[0];
+        }
+        public virtual TernaryTreeNode AddRightChild(char value, bool isFinal)
+        {
+            childs[2] = new TernaryTreeNode(this, value, isFinal);
+            return childs[2];
+        }
+        public virtual TernaryTreeNode AddMiddleChild(char value, bool isFinal)
+        {
+            childs[1] = new TernaryTreeNode(this, value, isFinal);
+            return childs[1];
+        }
+    }
+}