Implement R-ways search tries

Author: cschen1205

Algorithms/Algorithms.csproj

@@ -3,7 +3,6 @@
     <TargetFramework>netstandard1.4</TargetFramework>
   </PropertyGroup>
   <ItemGroup>
-    <Folder Include="DataStructures\SearchTries" />
     <Folder Include="Selection" />
   </ItemGroup>
   <ItemGroup>

Algorithms/DataStructures/SearchTries/ISearchTries.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Algorithms.DataStructures.SearchTries
+{
+    public interface ISearchTries<T>
+    {
+        T this[string key] { get; set; }
+
+        int Count { get; }
+        bool IsEmpty { get;  }
+
+        void Delete(String key);
+        bool ContainsKey(String key);
+
+        IEnumerable<string> Keys { get; }
+        IEnumerable<string> KeysWithPrefix(string prefix);
+    }
+}

Algorithms/DataStructures/SearchTries/RWayTries.cs

@@ -0,0 +1,131 @@
+
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Algorithms.DataStructures.Queue;
+using Algorithms.Utils;
+
+namespace Algorithms.DataStructures.SearchTries
+{
+    public class RWayTries<T> : ISearchTries<T>
+    {
+        private const int R = 256;
+        private int N = 0;
+
+        private class Node
+        {
+            internal T value;
+            internal Node[] children = new Node[R];
+        }
+
+        private Node root;
+
+        public T this[string key]
+        {
+            get
+            {
+                var 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();
+            }
+
+            if (key.Length == d)
+            {
+                if (ObjectUtil.IsNullOrDefault(x.value))
+                {
+                    N++;
+                }
+
+                x.value = value;
+                return x;
+            }
+
+            char v = key[d];
+            x.children[v] = Put(x.children[v], key, value, d + 1);
+            return x;
+        }
+
+        public void Delete(String key)
+        {
+            Node x = Get(root, key, 0);
+            if (x != null)
+            {
+                N--;
+                x.value = default(T);
+            }
+        }
+
+        public bool ContainsKey(String key)
+        {
+            Node x = Get(root, key, 0);
+            if (x == null) return false;
+            return !ObjectUtil.IsNullOrDefault(x.value);
+        }
+
+        public IEnumerable<string> Keys {
+            get
+            {
+                var queue = new QueueLinkedList<string>();
+
+                Collect(root, "", queue);
+
+                return queue;
+            }
+        }
+
+        public IEnumerable<string> KeysWithPrefix(string prefix)
+        {
+
+            Node x = Get(root, prefix, 0);
+            QueueLinkedList<String> queue = new QueueLinkedList<string>();
+            if (x != null)
+            {
+                Collect(x, prefix, queue);
+            }
+            return queue;
+        }
+
+        private void Collect(Node x, String prefix, IQueue<string> queue)
+        {
+            if (x == null) return;
+            if (!ObjectUtil.IsNullOrDefault(x.value))
+            {
+                queue.Enqueue(prefix);
+            }
+            for (int r = 0; r < R; ++r)
+            {
+                Collect(x.children[r], prefix + ((char)r), queue);
+            }
+        }
+
+        private Node Get(Node x, string key, int d)
+        {
+            if (x == null) return null;
+            if (key.Length == d) return x;
+            char v = key[d];
+            return Get(x.children[v], key, d + 1);
+        }
+
+        public int Count => N;
+        public bool IsEmpty => N == 0;
+
+
+    }
+}

Algorithms/Utils/ObjectUtil.cs

@@ -0,0 +1,28 @@
+using System;
+
+namespace Algorithms.Utils
+{
+    public class ObjectUtil
+    {
+        public static bool IsNullOrDefault<T>(T argument)
+        {
+            // deal with normal scenarios
+            if (argument == null) return true;
+            if (object.Equals(argument, default(T))) return true;
+
+            // deal with non-null nullables
+            Type methodType = typeof(T);
+            if (Nullable.GetUnderlyingType(methodType) != null) return false;
+
+            // deal with boxed value types
+            Type argumentType = argument.GetType();
+            if (argumentType != methodType)
+            {
+                object obj = Activator.CreateInstance(argument.GetType());
+                return obj.Equals(argument);
+            }
+
+            return false;
+        }
+    }
+}

AlgorithmsUnitTest/DataStrutures/SearchTries/RWayTriesUnitTest.cs

@@ -0,0 +1,56 @@
+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 RWayTriesUnitTest
+    {
+        private ITestOutputHelper console;
+        public RWayTriesUnitTest(ITestOutputHelper console)
+        {
+            this.console = console;
+        }
+
+        [Fact]
+        public void TestHashMap()
+        {
+            var map = new RWayTries<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);
+        }
+    }
+}