justcoding121
diff --git a/‎Advanced.Algorithms/DataStructures/Dictionary/Dictionary.cs‎
Lines changed: 22 additions & 19 deletions b/‎Advanced.Algorithms/DataStructures/Dictionary/Dictionary.cs‎
Lines changed: 22 additions & 19 deletions
diff --git a/‎Advanced.Algorithms/DataStructures/Dictionary/SortedDictionary.cs‎
Lines changed: 35 additions & 35 deletions b/‎Advanced.Algorithms/DataStructures/Dictionary/SortedDictionary.cs‎
Lines changed: 35 additions & 35 deletions
diff --git a/‎Advanced.Algorithms/DataStructures/HashSet/HashSet.cs‎
Lines changed: 19 additions & 16 deletions b/‎Advanced.Algorithms/DataStructures/HashSet/HashSet.cs‎
Lines changed: 19 additions & 16 deletions
@@ -8,10 +8,10 @@ namespace Advanced.Algorithms.DataStructures
     /// A dictionary implementation.
     /// </summary>
     /// <typeparam name="K">The key datatype.</typeparam>
-    /// <typeparam name="TV">The value datatype.</typeparam>
-    public class Dictionary<TK, TV> : IEnumerable<KeyValuePair<TK, TV>> 
+    /// <typeparam name="V">The value datatype.</typeparam>
+    public class Dictionary<K, V> : IEnumerable<KeyValuePair<K, V>> 
     {
-        private readonly IDictionary<TK, TV> dictionary;
+        private readonly IDictionary<K, V> dictionary;
 
         /// <summary>
         /// Constructor.
@@ -27,11 +27,11 @@ public Dictionary(DictionaryType type = DictionaryType.SeparateChaining, int ini
 
             if (type == DictionaryType.SeparateChaining)
             {
-                dictionary = new SeparateChainingDictionary<TK, TV>(initialBucketSize);
+                dictionary = new SeparateChainingDictionary<K, V>(initialBucketSize);
             }
             else
             {
-                dictionary = new OpenAddressDictionary<TK, TV>(initialBucketSize);
+                dictionary = new OpenAddressDictionary<K, V>(initialBucketSize);
             }
         }
 
@@ -44,7 +44,7 @@ public Dictionary(DictionaryType type = DictionaryType.SeparateChaining, int ini
         /// Get/set value for given key.
         /// Time complexity: O(1) amortized.
         /// </summary>
-        public TV this[TK key]
+        public V this[K key]
         {
             get => dictionary[key];
             set => dictionary[key] = value;
@@ -56,7 +56,7 @@ public TV this[TK key]
         /// </summary>
         /// <param name="value">The key to check.</param>
         /// <returns>True if this dictionary contains the given key.</returns>
-        public bool ContainsKey(TK key)
+        public bool ContainsKey(K key)
         {
             return dictionary.ContainsKey(key);
         }
@@ -67,7 +67,7 @@ public bool ContainsKey(TK key)
         /// </summary>
         /// <param name="key">The key to add.</param>
         /// <param name="value">The value for the given key.</param>
-        public void Add(TK key, TV value)
+        public void Add(K key, V value)
         {
             dictionary.Add(key, value);
         }
@@ -77,7 +77,7 @@ public void Add(TK key, TV value)
         /// Time complexity: O(1) amortized.
         /// </summary>
         /// <param name="key">The key to remove.</param>
-        public void Remove(TK key)
+        public void Remove(K key)
         {
             dictionary.Remove(key);
         }
@@ -96,36 +96,39 @@ IEnumerator IEnumerable.GetEnumerator()
             return GetEnumerator();
         }
 
-        public IEnumerator<KeyValuePair<TK, TV>> GetEnumerator()
+        public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
         {
             return dictionary.GetEnumerator();
         }
     }
 
-    internal interface IDictionary<TK, TV> : IEnumerable<KeyValuePair<TK, TV>>
+    internal interface IDictionary<K, V> : IEnumerable<KeyValuePair<K, V>>
     {
-        TV this[TK key] { get; set; }
+        V this[K key] { get; set; }
 
-        bool ContainsKey(TK key);
-        void Add(TK key, TV value);
-        void Remove(TK key);
+        bool ContainsKey(K key);
+        void Add(K key, V value);
+        void Remove(K key);
         void Clear();
 
         int Count { get; }
     }
 
-    internal class DictionaryNode<TK, TV>
+    internal class DictionaryNode<K, V>
     {
-        internal TK Key;
-        internal TV Value;
+        internal K Key;
+        internal V Value;
 
-        internal DictionaryNode(TK key, TV value)
+        internal DictionaryNode(K key, V value)
         {
             this.Key = key;
             this.Value = value;
         }
     }
 
+    /// <summary>
+    /// The dictionary implementation type.
+    /// </summary>
     public enum DictionaryType
     {
         SeparateChaining,
 
@@ -8,18 +8,18 @@ namespace Advanced.Algorithms.DataStructures
     /// A sorted Dictionary implementation using balanced binary search tree. IEnumerable will enumerate in sorted order.
     /// This may be better than regular Dictionary implementation which can give o(K) in worst case (but O(1) amortized when collisions K is avoided).
     /// </summary>
-    /// <typeparam name="TK">The key datatype.</typeparam>
-    /// <typeparam name="TV">The value datatype.</typeparam>
-    public class SortedDictionary<TK, TV> : IEnumerable<KeyValuePair<TK, TV>> where TK : IComparable
+    /// <typeparam name="K">The key datatype.</typeparam>
+    /// <typeparam name="V">The value datatype.</typeparam>
+    public class SortedDictionary<K, V> : IEnumerable<KeyValuePair<K, V>> where K : IComparable
     {
         //use red-black tree as our balanced BST since it gives good performance for both deletion/insertion
-        private readonly RedBlackTree<SortedDictionaryNode<TK, TV>> binarySearchTree;
+        private readonly RedBlackTree<SortedDictionaryNode<K, V>> binarySearchTree;
 
         public int Count => binarySearchTree.Count;
 
         public SortedDictionary()
         {
-            binarySearchTree = new RedBlackTree<SortedDictionaryNode<TK, TV>>();
+            binarySearchTree = new RedBlackTree<SortedDictionaryNode<K, V>>();
         }
 
         /// <summary>
@@ -28,29 +28,29 @@ public SortedDictionary()
         /// </summary>
         /// <param name="key">The key to check.</param>
         /// <returns>True if this dictionary contains the given key.</returns> 
-        public bool ContainsKey(TK key)
+        public bool ContainsKey(K key)
         {
-            return binarySearchTree.HasItem(new SortedDictionaryNode<TK, TV>(key, default(TV)));
+            return binarySearchTree.HasItem(new SortedDictionaryNode<K, V>(key, default(V)));
         }
 
         /// <summary>
         /// Add a new value for given key.
         /// Time complexity: O(log(n)).
         /// </summary>
-        public void Add(TK key, TV value)
+        public void Add(K key, V value)
         {
-            binarySearchTree.Insert(new SortedDictionaryNode<TK, TV>(key, value));
+            binarySearchTree.Insert(new SortedDictionaryNode<K, V>(key, value));
         }
 
         /// <summary>
         /// Get/set value for given key.
         /// Time complexity: O(log(n)).
         /// </summary>
-        public TV this[TK key]
+        public V this[K key]
         {
             get
             {
-                var node = binarySearchTree.FindNode(new SortedDictionaryNode<TK, TV>(key, default(TV)));
+                var node = binarySearchTree.FindNode(new SortedDictionaryNode<K, V>(key, default(V)));
                 if (node == null)
                 {
                     throw new Exception("Key not found.");
@@ -73,43 +73,43 @@ public TV this[TK key]
         /// Remove the given key.
         /// Time complexity: O(log(n)).
         /// </summary>
-        public void Remove(TK key)
+        public void Remove(K key)
         {
-            binarySearchTree.Delete(new SortedDictionaryNode<TK, TV>(key, default(TV)));
+            binarySearchTree.Delete(new SortedDictionaryNode<K, V>(key, default(V)));
         }
 
         /// <summary>
         /// Return the next higher key-value pair after given key in this dictionary.
         /// Time complexity: O(log(n)).
         /// </summary>
         /// <returns>Null if the given key does'nt exist or next key does'nt exist.</returns>
-        public KeyValuePair<TK, TV> NextHigher(TK key)
+        public KeyValuePair<K, V> NextHigher(K key)
         {
-            var next = binarySearchTree.NextHigher(new SortedDictionaryNode<TK, TV>(key, default(TV)));
+            var next = binarySearchTree.NextHigher(new SortedDictionaryNode<K, V>(key, default(V)));
 
             if(next == null)
             {
-                return default(KeyValuePair<TK, TV>);
+                return default(KeyValuePair<K, V>);
             }
 
-            return new KeyValuePair<TK, TV>(next.Key, next.Value);
+            return new KeyValuePair<K, V>(next.Key, next.Value);
         }
 
         /// <summary>
         /// Return the next lower key-value pair before given key in this dictionary.
         /// Time complexity: O(log(n)).
         /// </summary>
         /// <returns>Null if the given key does'nt exist or previous key does'nt exist.</returns>
-        public KeyValuePair<TK, TV> NextLower(TK key)
+        public KeyValuePair<K, V> NextLower(K key)
         {
-            var prev = binarySearchTree.NextLower(new SortedDictionaryNode<TK, TV>(key, default(TV)));
+            var prev = binarySearchTree.NextLower(new SortedDictionaryNode<K, V>(key, default(V)));
 
             if (prev == null)
             {
-                return default(KeyValuePair<TK, TV>);
+                return default(KeyValuePair<K, V>);
             }
 
-            return new KeyValuePair<TK, TV>(prev.Key, prev.Value);
+            return new KeyValuePair<K, V>(prev.Key, prev.Value);
         }
 
         /// <summary>
@@ -126,27 +126,27 @@ IEnumerator IEnumerable.GetEnumerator()
             return GetEnumerator();
         }
 
-        public IEnumerator<KeyValuePair<TK, TV>> GetEnumerator()
+        public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
         {
-            return new SortedDictionaryEnumerator<TK, TV>(binarySearchTree);
+            return new SortedDictionaryEnumerator<K, V>(binarySearchTree);
         }
     }
 
-    internal class SortedDictionaryNode<TK, TV> : IComparable
-                                 where TK : IComparable
+    internal class SortedDictionaryNode<K, V> : IComparable
+                                 where K : IComparable
     {
-        internal TK Key { get; }
-        internal TV Value { get; set; }
+        internal K Key { get; }
+        internal V Value { get; set; }
 
-        internal SortedDictionaryNode(TK key, TV value)
+        internal SortedDictionaryNode(K key, V value)
         {
             this.Key = key;
             this.Value = value;
         }
 
         public int CompareTo(object obj)
         {
-            if (obj is SortedDictionaryNode<TK, TV> itemToComare)
+            if (obj is SortedDictionaryNode<K, V> itemToComare)
             {
                 return Key.CompareTo(itemToComare.Key);
             }
@@ -155,12 +155,12 @@ public int CompareTo(object obj)
         }
     }
 
-    internal class SortedDictionaryEnumerator<TK, TV> : IEnumerator<KeyValuePair<TK, TV>> where TK : IComparable
+    internal class SortedDictionaryEnumerator<K, V> : IEnumerator<KeyValuePair<K, V>> where K : IComparable
     {
-        private RedBlackTree<SortedDictionaryNode<TK, TV>> bst;
-        private IEnumerator<SortedDictionaryNode<TK, TV>> enumerator;
+        private RedBlackTree<SortedDictionaryNode<K, V>> bst;
+        private IEnumerator<SortedDictionaryNode<K, V>> enumerator;
 
-        internal SortedDictionaryEnumerator(RedBlackTree<SortedDictionaryNode<TK, TV>> bst)
+        internal SortedDictionaryEnumerator(RedBlackTree<SortedDictionaryNode<K, V>> bst)
         {
             this.bst = bst;
             this.enumerator = bst.GetEnumerator();
@@ -178,11 +178,11 @@ public void Reset()
 
         object IEnumerator.Current => Current;
 
-        public KeyValuePair<TK, TV> Current
+        public KeyValuePair<K, V> Current
         {
             get
             {
-                return new KeyValuePair<TK, TV>(enumerator.Current.Key, enumerator.Current.Value);
+                return new KeyValuePair<K, V>(enumerator.Current.Key, enumerator.Current.Value);
             }
         }
 
 
@@ -7,10 +7,10 @@ namespace Advanced.Algorithms.DataStructures
     /// <summary>
     /// A hash table implementation.
     /// </summary>
-    /// <typeparam name="TV">The value datatype.</typeparam>
-    public class HashSet<TV> : IEnumerable<HashSetNode<TV>> 
+    /// <typeparam name="T">The value datatype.</typeparam>
+    public class HashSet<T> : IEnumerable<HashSetNode<T>> 
     {
-        private readonly IHashSet<TV> hashSet;
+        private readonly IHashSet<T> hashSet;
 
         /// <summary>
         /// Constructor.
@@ -26,11 +26,11 @@ public HashSet(HashSetType type = HashSetType.SeparateChaining, int initialBucke
             }
             if (type == HashSetType.SeparateChaining)
             {
-                hashSet = new SeparateChainingHashSet<TV>(initialBucketSize);
+                hashSet = new SeparateChainingHashSet<T>(initialBucketSize);
             }
             else
             {
-                hashSet = new OpenAddressHashSet<TV>(initialBucketSize);
+                hashSet = new OpenAddressHashSet<T>(initialBucketSize);
             }
         }
 
@@ -46,7 +46,7 @@ public HashSet(HashSetType type = HashSetType.SeparateChaining, int initialBucke
         /// </summary>
         /// <param name="value">The value to check.</param>
         /// <returns>True if this hashset contains the given value.</returns>
-        public bool Contains(TV value)
+        public bool Contains(T value)
         {
             return hashSet.Contains(value);
         }
@@ -56,7 +56,7 @@ public bool Contains(TV value)
         /// Time complexity: O(1) amortized.
         /// </summary>
         /// <param name="value">The value to add.</param>
-        public void Add(TV value)
+        public void Add(T value)
         {
             hashSet.Add(value);
         }
@@ -66,7 +66,7 @@ public void Add(TV value)
         /// Time complexity: O(1) amortized.
         /// </summary>
         /// <param name="value">The value to remove.</param>
-        public void Remove(TV value)
+        public void Remove(T value)
         {
             hashSet.Remove(value);
         }
@@ -85,32 +85,35 @@ IEnumerator IEnumerable.GetEnumerator()
             return hashSet.GetEnumerator();
         }
 
-        public IEnumerator<HashSetNode<TV>> GetEnumerator()
+        public IEnumerator<HashSetNode<T>> GetEnumerator()
         {
             return hashSet.GetEnumerator();
         }
     }
 
-    internal interface IHashSet<TV> : IEnumerable<HashSetNode<TV>>
+    internal interface IHashSet<T> : IEnumerable<HashSetNode<T>>
     {
-        bool Contains(TV value);
-        void Add(TV value);
-        void Remove(TV key);
+        bool Contains(T value);
+        void Add(T value);
+        void Remove(T key);
         void Clear();
 
         int Count { get; }
     }
 
-    public class HashSetNode<TV>
+    public class HashSetNode<T>
     {
-        public TV Value;
+        public T Value;
 
-        public HashSetNode(TV value)
+        public HashSetNode(T value)
         {
             this.Value = value;
         }
     }
 
+    /// <summary>
+    /// The hash set implementation type.
+    /// </summary>
     public enum HashSetType
     {
         SeparateChaining,
Original file line number	Diff line number	Diff line change
`@@ -8,10 +8,10 @@ namespace Advanced.Algorithms.DataStructures`
`8`	`8`	`/// A dictionary implementation.`
`9`	`9`	`/// </summary>`
`10`	`10`	`/// <typeparam name="K">The key datatype.</typeparam>`
`11`		`- /// <typeparam name="TV">The value datatype.</typeparam>`
`12`		`- public class Dictionary<TK, TV> : IEnumerable<KeyValuePair<TK, TV>>`
	`11`	`+ /// <typeparam name="V">The value datatype.</typeparam>`
	`12`	`+ public class Dictionary<K, V> : IEnumerable<KeyValuePair<K, V>>`
`13`	`13`	`{`
`14`		`- private readonly IDictionary<TK, TV> dictionary;`
	`14`	`+ private readonly IDictionary<K, V> dictionary;`
`15`	`15`
`16`	`16`	`/// <summary>`
`17`	`17`	`/// Constructor.`
`@@ -27,11 +27,11 @@ public Dictionary(DictionaryType type = DictionaryType.SeparateChaining, int ini`
`27`	`27`
`28`	`28`	`if (type == DictionaryType.SeparateChaining)`
`29`	`29`	`{`
`30`		`- dictionary = new SeparateChainingDictionary<TK, TV>(initialBucketSize);`
	`30`	`+ dictionary = new SeparateChainingDictionary<K, V>(initialBucketSize);`
`31`	`31`	`}`
`32`	`32`	`else`
`33`	`33`	`{`
`34`		`- dictionary = new OpenAddressDictionary<TK, TV>(initialBucketSize);`
	`34`	`+ dictionary = new OpenAddressDictionary<K, V>(initialBucketSize);`
`35`	`35`	`}`
`36`	`36`	`}`
`37`	`37`
`@@ -44,7 +44,7 @@ public Dictionary(DictionaryType type = DictionaryType.SeparateChaining, int ini`
`44`	`44`	`/// Get/set value for given key.`
`45`	`45`	`/// Time complexity: O(1) amortized.`
`46`	`46`	`/// </summary>`
`47`		`- public TV this[TK key]`
	`47`	`+ public V this[K key]`
`48`	`48`	`{`
`49`	`49`	`get => dictionary[key];`
`50`	`50`	`set => dictionary[key] = value;`
`@@ -56,7 +56,7 @@ public TV this[TK key]`
`56`	`56`	`/// </summary>`
`57`	`57`	`/// <param name="value">The key to check.</param>`
`58`	`58`	`/// <returns>True if this dictionary contains the given key.</returns>`
`59`		`- public bool ContainsKey(TK key)`
	`59`	`+ public bool ContainsKey(K key)`
`60`	`60`	`{`
`61`	`61`	`return dictionary.ContainsKey(key);`
`62`	`62`	`}`
`@@ -67,7 +67,7 @@ public bool ContainsKey(TK key)`
`67`	`67`	`/// </summary>`
`68`	`68`	`/// <param name="key">The key to add.</param>`
`69`	`69`	`/// <param name="value">The value for the given key.</param>`
`70`		`- public void Add(TK key, TV value)`
	`70`	`+ public void Add(K key, V value)`
`71`	`71`	`{`
`72`	`72`	`dictionary.Add(key, value);`
`73`	`73`	`}`
`@@ -77,7 +77,7 @@ public void Add(TK key, TV value)`
`77`	`77`	`/// Time complexity: O(1) amortized.`
`78`	`78`	`/// </summary>`
`79`	`79`	`/// <param name="key">The key to remove.</param>`
`80`		`- public void Remove(TK key)`
	`80`	`+ public void Remove(K key)`
`81`	`81`	`{`
`82`	`82`	`dictionary.Remove(key);`
`83`	`83`	`}`
`@@ -96,36 +96,39 @@ IEnumerator IEnumerable.GetEnumerator()`
`96`	`96`	`return GetEnumerator();`
`97`	`97`	`}`
`98`	`98`
`99`		`- public IEnumerator<KeyValuePair<TK, TV>> GetEnumerator()`
	`99`	`+ public IEnumerator<KeyValuePair<K, V>> GetEnumerator()`
`100`	`100`	`{`
`101`	`101`	`return dictionary.GetEnumerator();`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`
`105`		`- internal interface IDictionary<TK, TV> : IEnumerable<KeyValuePair<TK, TV>>`
	`105`	`+ internal interface IDictionary<K, V> : IEnumerable<KeyValuePair<K, V>>`
`106`	`106`	`{`
`107`		`- TV this[TK key] { get; set; }`
	`107`	`+ V this[K key] { get; set; }`
`108`	`108`
`109`		`- bool ContainsKey(TK key);`
`110`		`- void Add(TK key, TV value);`
`111`		`- void Remove(TK key);`
	`109`	`+ bool ContainsKey(K key);`
	`110`	`+ void Add(K key, V value);`
	`111`	`+ void Remove(K key);`
`112`	`112`	`void Clear();`
`113`	`113`
`114`	`114`	`int Count { get; }`
`115`	`115`	`}`
`116`	`116`
`117`		`- internal class DictionaryNode<TK, TV>`
	`117`	`+ internal class DictionaryNode<K, V>`
`118`	`118`	`{`
`119`		`- internal TK Key;`
`120`		`- internal TV Value;`
	`119`	`+ internal K Key;`
	`120`	`+ internal V Value;`
`121`	`121`
`122`		`- internal DictionaryNode(TK key, TV value)`
	`122`	`+ internal DictionaryNode(K key, V value)`
`123`	`123`	`{`
`124`	`124`	`this.Key = key;`
`125`	`125`	`this.Value = value;`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`
	`129`	`+ /// <summary>`
	`130`	`+ /// The dictionary implementation type.`
	`131`	`+ /// </summary>`
`129`	`132`	`public enum DictionaryType`
`130`	`133`	`{`
`131`	`134`	`SeparateChaining,`
Original file line number	Diff line number	Diff line change
`@@ -8,18 +8,18 @@ namespace Advanced.Algorithms.DataStructures`
`8`	`8`	`/// A sorted Dictionary implementation using balanced binary search tree. IEnumerable will enumerate in sorted order.`
`9`	`9`	`/// This may be better than regular Dictionary implementation which can give o(K) in worst case (but O(1) amortized when collisions K is avoided).`
`10`	`10`	`/// </summary>`
`11`		`- /// <typeparam name="TK">The key datatype.</typeparam>`
`12`		`- /// <typeparam name="TV">The value datatype.</typeparam>`
`13`		`- public class SortedDictionary<TK, TV> : IEnumerable<KeyValuePair<TK, TV>> where TK : IComparable`
	`11`	`+ /// <typeparam name="K">The key datatype.</typeparam>`
	`12`	`+ /// <typeparam name="V">The value datatype.</typeparam>`
	`13`	`+ public class SortedDictionary<K, V> : IEnumerable<KeyValuePair<K, V>> where K : IComparable`
`14`	`14`	`{`
`15`	`15`	`//use red-black tree as our balanced BST since it gives good performance for both deletion/insertion`
`16`		`- private readonly RedBlackTree<SortedDictionaryNode<TK, TV>> binarySearchTree;`
	`16`	`+ private readonly RedBlackTree<SortedDictionaryNode<K, V>> binarySearchTree;`
`17`	`17`
`18`	`18`	`public int Count => binarySearchTree.Count;`
`19`	`19`
`20`	`20`	`public SortedDictionary()`
`21`	`21`	`{`
`22`		`- binarySearchTree = new RedBlackTree<SortedDictionaryNode<TK, TV>>();`
	`22`	`+ binarySearchTree = new RedBlackTree<SortedDictionaryNode<K, V>>();`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`/// <summary>`
`@@ -28,29 +28,29 @@ public SortedDictionary()`
`28`	`28`	`/// </summary>`
`29`	`29`	`/// <param name="key">The key to check.</param>`
`30`	`30`	`/// <returns>True if this dictionary contains the given key.</returns>`
`31`		`- public bool ContainsKey(TK key)`
	`31`	`+ public bool ContainsKey(K key)`
`32`	`32`	`{`
`33`		`- return binarySearchTree.HasItem(new SortedDictionaryNode<TK, TV>(key, default(TV)));`
	`33`	`+ return binarySearchTree.HasItem(new SortedDictionaryNode<K, V>(key, default(V)));`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`/// <summary>`
`37`	`37`	`/// Add a new value for given key.`
`38`	`38`	`/// Time complexity: O(log(n)).`
`39`	`39`	`/// </summary>`
`40`		`- public void Add(TK key, TV value)`
	`40`	`+ public void Add(K key, V value)`
`41`	`41`	`{`
`42`		`- binarySearchTree.Insert(new SortedDictionaryNode<TK, TV>(key, value));`
	`42`	`+ binarySearchTree.Insert(new SortedDictionaryNode<K, V>(key, value));`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`/// <summary>`
`46`	`46`	`/// Get/set value for given key.`
`47`	`47`	`/// Time complexity: O(log(n)).`
`48`	`48`	`/// </summary>`
`49`		`- public TV this[TK key]`
	`49`	`+ public V this[K key]`
`50`	`50`	`{`
`51`	`51`	`get`
`52`	`52`	`{`
`53`		`- var node = binarySearchTree.FindNode(new SortedDictionaryNode<TK, TV>(key, default(TV)));`
	`53`	`+ var node = binarySearchTree.FindNode(new SortedDictionaryNode<K, V>(key, default(V)));`
`54`	`54`	`if (node == null)`
`55`	`55`	`{`
`56`	`56`	`throw new Exception("Key not found.");`
`@@ -73,43 +73,43 @@ public TV this[TK key]`
`73`	`73`	`/// Remove the given key.`
`74`	`74`	`/// Time complexity: O(log(n)).`
`75`	`75`	`/// </summary>`
`76`		`- public void Remove(TK key)`
	`76`	`+ public void Remove(K key)`
`77`	`77`	`{`
`78`		`- binarySearchTree.Delete(new SortedDictionaryNode<TK, TV>(key, default(TV)));`
	`78`	`+ binarySearchTree.Delete(new SortedDictionaryNode<K, V>(key, default(V)));`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`/// <summary>`
`82`	`82`	`/// Return the next higher key-value pair after given key in this dictionary.`
`83`	`83`	`/// Time complexity: O(log(n)).`
`84`	`84`	`/// </summary>`
`85`	`85`	`/// <returns>Null if the given key does'nt exist or next key does'nt exist.</returns>`
`86`		`- public KeyValuePair<TK, TV> NextHigher(TK key)`
	`86`	`+ public KeyValuePair<K, V> NextHigher(K key)`
`87`	`87`	`{`
`88`		`- var next = binarySearchTree.NextHigher(new SortedDictionaryNode<TK, TV>(key, default(TV)));`
	`88`	`+ var next = binarySearchTree.NextHigher(new SortedDictionaryNode<K, V>(key, default(V)));`
`89`	`89`
`90`	`90`	`if(next == null)`
`91`	`91`	`{`
`92`		`- return default(KeyValuePair<TK, TV>);`
	`92`	`+ return default(KeyValuePair<K, V>);`
`93`	`93`	`}`
`94`	`94`
`95`		`- return new KeyValuePair<TK, TV>(next.Key, next.Value);`
	`95`	`+ return new KeyValuePair<K, V>(next.Key, next.Value);`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`/// <summary>`
`99`	`99`	`/// Return the next lower key-value pair before given key in this dictionary.`
`100`	`100`	`/// Time complexity: O(log(n)).`
`101`	`101`	`/// </summary>`
`102`	`102`	`/// <returns>Null if the given key does'nt exist or previous key does'nt exist.</returns>`
`103`		`- public KeyValuePair<TK, TV> NextLower(TK key)`
	`103`	`+ public KeyValuePair<K, V> NextLower(K key)`
`104`	`104`	`{`
`105`		`- var prev = binarySearchTree.NextLower(new SortedDictionaryNode<TK, TV>(key, default(TV)));`
	`105`	`+ var prev = binarySearchTree.NextLower(new SortedDictionaryNode<K, V>(key, default(V)));`
`106`	`106`
`107`	`107`	`if (prev == null)`
`108`	`108`	`{`
`109`		`- return default(KeyValuePair<TK, TV>);`
	`109`	`+ return default(KeyValuePair<K, V>);`
`110`	`110`	`}`
`111`	`111`
`112`		`- return new KeyValuePair<TK, TV>(prev.Key, prev.Value);`
	`112`	`+ return new KeyValuePair<K, V>(prev.Key, prev.Value);`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`/// <summary>`
`@@ -126,27 +126,27 @@ IEnumerator IEnumerable.GetEnumerator()`
`126`	`126`	`return GetEnumerator();`
`127`	`127`	`}`
`128`	`128`
`129`		`- public IEnumerator<KeyValuePair<TK, TV>> GetEnumerator()`
	`129`	`+ public IEnumerator<KeyValuePair<K, V>> GetEnumerator()`
`130`	`130`	`{`
`131`		`- return new SortedDictionaryEnumerator<TK, TV>(binarySearchTree);`
	`131`	`+ return new SortedDictionaryEnumerator<K, V>(binarySearchTree);`
`132`	`132`	`}`
`133`	`133`	`}`
`134`	`134`
`135`		`- internal class SortedDictionaryNode<TK, TV> : IComparable`
`136`		`- where TK : IComparable`
	`135`	`+ internal class SortedDictionaryNode<K, V> : IComparable`
	`136`	`+ where K : IComparable`
`137`	`137`	`{`
`138`		`- internal TK Key { get; }`
`139`		`- internal TV Value { get; set; }`
	`138`	`+ internal K Key { get; }`
	`139`	`+ internal V Value { get; set; }`
`140`	`140`
`141`		`- internal SortedDictionaryNode(TK key, TV value)`
	`141`	`+ internal SortedDictionaryNode(K key, V value)`
`142`	`142`	`{`
`143`	`143`	`this.Key = key;`
`144`	`144`	`this.Value = value;`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`public int CompareTo(object obj)`
`148`	`148`	`{`
`149`		`- if (obj is SortedDictionaryNode<TK, TV> itemToComare)`
	`149`	`+ if (obj is SortedDictionaryNode<K, V> itemToComare)`
`150`	`150`	`{`
`151`	`151`	`return Key.CompareTo(itemToComare.Key);`
`152`	`152`	`}`
`@@ -155,12 +155,12 @@ public int CompareTo(object obj)`
`155`	`155`	`}`
`156`	`156`	`}`
`157`	`157`
`158`		`- internal class SortedDictionaryEnumerator<TK, TV> : IEnumerator<KeyValuePair<TK, TV>> where TK : IComparable`
	`158`	`+ internal class SortedDictionaryEnumerator<K, V> : IEnumerator<KeyValuePair<K, V>> where K : IComparable`
`159`	`159`	`{`
`160`		`- private RedBlackTree<SortedDictionaryNode<TK, TV>> bst;`
`161`		`- private IEnumerator<SortedDictionaryNode<TK, TV>> enumerator;`
	`160`	`+ private RedBlackTree<SortedDictionaryNode<K, V>> bst;`
	`161`	`+ private IEnumerator<SortedDictionaryNode<K, V>> enumerator;`
`162`	`162`
`163`		`- internal SortedDictionaryEnumerator(RedBlackTree<SortedDictionaryNode<TK, TV>> bst)`
	`163`	`+ internal SortedDictionaryEnumerator(RedBlackTree<SortedDictionaryNode<K, V>> bst)`
`164`	`164`	`{`
`165`	`165`	`this.bst = bst;`
`166`	`166`	`this.enumerator = bst.GetEnumerator();`
`@@ -178,11 +178,11 @@ public void Reset()`
`178`	`178`
`179`	`179`	`object IEnumerator.Current => Current;`
`180`	`180`
`181`		`- public KeyValuePair<TK, TV> Current`
	`181`	`+ public KeyValuePair<K, V> Current`
`182`	`182`	`{`
`183`	`183`	`get`
`184`	`184`	`{`
`185`		`- return new KeyValuePair<TK, TV>(enumerator.Current.Key, enumerator.Current.Value);`
	`185`	`+ return new KeyValuePair<K, V>(enumerator.Current.Key, enumerator.Current.Value);`
`186`	`186`	`}`
`187`	`187`	`}`
`188`	`188`
Original file line number	Diff line number	Diff line change
`@@ -7,10 +7,10 @@ namespace Advanced.Algorithms.DataStructures`
`7`	`7`	`/// <summary>`
`8`	`8`	`/// A hash table implementation.`
`9`	`9`	`/// </summary>`
`10`		`- /// <typeparam name="TV">The value datatype.</typeparam>`
`11`		`- public class HashSet<TV> : IEnumerable<HashSetNode<TV>>`
	`10`	`+ /// <typeparam name="T">The value datatype.</typeparam>`
	`11`	`+ public class HashSet<T> : IEnumerable<HashSetNode<T>>`
`12`	`12`	`{`
`13`		`- private readonly IHashSet<TV> hashSet;`
	`13`	`+ private readonly IHashSet<T> hashSet;`
`14`	`14`
`15`	`15`	`/// <summary>`
`16`	`16`	`/// Constructor.`
`@@ -26,11 +26,11 @@ public HashSet(HashSetType type = HashSetType.SeparateChaining, int initialBucke`
`26`	`26`	`}`
`27`	`27`	`if (type == HashSetType.SeparateChaining)`
`28`	`28`	`{`
`29`		`- hashSet = new SeparateChainingHashSet<TV>(initialBucketSize);`
	`29`	`+ hashSet = new SeparateChainingHashSet<T>(initialBucketSize);`
`30`	`30`	`}`
`31`	`31`	`else`
`32`	`32`	`{`
`33`		`- hashSet = new OpenAddressHashSet<TV>(initialBucketSize);`
	`33`	`+ hashSet = new OpenAddressHashSet<T>(initialBucketSize);`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
`@@ -46,7 +46,7 @@ public HashSet(HashSetType type = HashSetType.SeparateChaining, int initialBucke`
`46`	`46`	`/// </summary>`
`47`	`47`	`/// <param name="value">The value to check.</param>`
`48`	`48`	`/// <returns>True if this hashset contains the given value.</returns>`
`49`		`- public bool Contains(TV value)`
	`49`	`+ public bool Contains(T value)`
`50`	`50`	`{`
`51`	`51`	`return hashSet.Contains(value);`
`52`	`52`	`}`
`@@ -56,7 +56,7 @@ public bool Contains(TV value)`
`56`	`56`	`/// Time complexity: O(1) amortized.`
`57`	`57`	`/// </summary>`
`58`	`58`	`/// <param name="value">The value to add.</param>`
`59`		`- public void Add(TV value)`
	`59`	`+ public void Add(T value)`
`60`	`60`	`{`
`61`	`61`	`hashSet.Add(value);`
`62`	`62`	`}`
`@@ -66,7 +66,7 @@ public void Add(TV value)`
`66`	`66`	`/// Time complexity: O(1) amortized.`
`67`	`67`	`/// </summary>`
`68`	`68`	`/// <param name="value">The value to remove.</param>`
`69`		`- public void Remove(TV value)`
	`69`	`+ public void Remove(T value)`
`70`	`70`	`{`
`71`	`71`	`hashSet.Remove(value);`
`72`	`72`	`}`
`@@ -85,32 +85,35 @@ IEnumerator IEnumerable.GetEnumerator()`
`85`	`85`	`return hashSet.GetEnumerator();`
`86`	`86`	`}`
`87`	`87`
`88`		`- public IEnumerator<HashSetNode<TV>> GetEnumerator()`
	`88`	`+ public IEnumerator<HashSetNode<T>> GetEnumerator()`
`89`	`89`	`{`
`90`	`90`	`return hashSet.GetEnumerator();`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`
`94`		`- internal interface IHashSet<TV> : IEnumerable<HashSetNode<TV>>`
	`94`	`+ internal interface IHashSet<T> : IEnumerable<HashSetNode<T>>`
`95`	`95`	`{`
`96`		`- bool Contains(TV value);`
`97`		`- void Add(TV value);`
`98`		`- void Remove(TV key);`
	`96`	`+ bool Contains(T value);`
	`97`	`+ void Add(T value);`
	`98`	`+ void Remove(T key);`
`99`	`99`	`void Clear();`
`100`	`100`
`101`	`101`	`int Count { get; }`
`102`	`102`	`}`
`103`	`103`
`104`		`- public class HashSetNode<TV>`
	`104`	`+ public class HashSetNode<T>`
`105`	`105`	`{`
`106`		`- public TV Value;`
	`106`	`+ public T Value;`
`107`	`107`
`108`		`- public HashSetNode(TV value)`
	`108`	`+ public HashSetNode(T value)`
`109`	`109`	`{`
`110`	`110`	`this.Value = value;`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`
	`114`	`+ /// <summary>`
	`115`	`+ /// The hash set implementation type.`
	`116`	`+ /// </summary>`
`114`	`117`	`public enum HashSetType`
`115`	`118`	`{`
`116`	`119`	`SeparateChaining,`