Implement ternary search tries partial

Author: cschen1205

Algorithms/DataStructures/SearchTries/TernarySearchTries.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using Algorithms.Utils;
+
+namespace Algorithms.DataStructures.SearchTries
+{
+    public class TernarySearchTries<T> : ISearchTries<T>
+    {
+        private class Node
+        {
+            internal char key;
+            internal T value;
+            internal Node left;
+            internal Node mid;
+            internal Node right;
+        }
+
+        private Node root;
+        private int N;
+
+        public T this[string key]
+        {
+            get
+            {
+                Node x = Get(root, key, 0);
+                if (x != null)
+                {
+                    return x.value;
+                }
+                return default(T);
+            }
+            set { root = Put(root, key, value, 0); }
+        }
+
+        private Node Put(Node x, string key, T value, int d)
+        {
+            if (x == null)
+            {
+                x = new Node
+                {
+                    key = key[d]
+                };
+            }
+
+            int cmp = key[d].CompareTo(x.key);
+            if (cmp < 0)
+            {
+                x.left = Put(x.left, key, value, d);
+            } else if (cmp > 0)
+            {
+                x.right = Put(x.right, key, value, d);
+            }
+            else
+            {
+                if (d >= key.Length-1)
+                {
+                    if (ObjectUtil.IsNullOrDefault(x.value))
+                    {
+                        N++;
+                    }
+                    x.value = value;
+                }
+                else
+                {
+                    x.mid = Put(x.mid, key, value, d + 1);
+                }
+            }
+            return x;
+        }
+
+        private Node Get(Node x, string key, int d)
+        {
+            if (x == null)
+            {
+                return null;
+            }
+
+            int cmp = key[d].CompareTo(x.key);
+
+            if (cmp < 0) return Get(x.left, key, d);
+            if (cmp > 0) return Get(x.right, key, d);
+            if (key.Length - 1 == d)
+            {
+                return x;
+            }
+            return Get(x.mid, key, d + 1);
+        }
+
+        public int Count => N;
+        public bool IsEmpty => N == 0;
+        public void Delete(string key)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public bool ContainsKey(string key)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public IEnumerable<string> Keys { get; }
+        public IEnumerable<string> KeysWithPrefix(string prefix)
+        {
+            throw new System.NotImplementedException();
+        }
+    }
+}

AlgorithmsUnitTest/DataStrutures/SearchTries/RWayTriesUnitTest.cs

@@ -16,7 +16,7 @@ public RWayTriesUnitTest(ITestOutputHelper console)
         }
 
         [Fact]
-        public void TestHashMap()
+        public void TestSearchTries()
         {
             var map = new RWayTries<int>();
             Assert.True(map.IsEmpty);

AlgorithmsUnitTest/DataStrutures/SearchTries/TernarySearchTriesUnitTest.cs

@@ -0,0 +1,57 @@
+using System.Reflection.PortableExecutable;
+using Algorithms.DataStructures.HashMap;
+using Algorithms.DataStructures.SearchTries;
+using Algorithms.DataStructures.TreeMap;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace AlgorithmsUnitTest.DataStrutures.TreeMap
+{
+    public class TernarySearchTriesUnitTest
+    {
+        private ITestOutputHelper console;
+        public TernarySearchTriesUnitTest(ITestOutputHelper console)
+        {
+            this.console = console;
+        }
+
+        [Fact]
+        public void TestSearchTries()
+        {
+            var map = new TernarySearchTries<int>();
+            Assert.True(map.IsEmpty);
+            map["one"] = 1;
+            Assert.Equal(1, map["one"]);
+            map["two"] = 2;
+            Assert.Equal(2, map["two"]);
+            Assert.Equal(2, map.Count);
+
+
+            /*
+            map.Delete("two");
+            Assert.Equal(1, map.Count);
+            Assert.True(map.ContainsKey("one"));
+            Assert.False(map.ContainsKey("two"));
+            Assert.False(map.IsEmpty);
+
+
+            foreach(var key in map.Keys)
+            {
+                console.WriteLine("{0}", key);
+            }
+
+            map["test"] = 3;
+            map["te"] = 4;
+            map["team"] = 4;
+            map["dream"] = 2;
+
+            int count = 0;
+            foreach (var key in map.KeysWithPrefix("te"))
+            {
+                count++;
+                console.WriteLine("{0}", key);
+            }
+            Assert.Equal(3, count);*/
+        }
+    }
+}