ienumerable for sets

Author: justcoding121

Advanced.Algorithms.Tests/DataStructures/Set/DisJointSet_Tests.cs

@@ -1,6 +1,6 @@
 using Advanced.Algorithms.DataStructures;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-
+using System.Linq;
 
 namespace Advanced.Algorithms.Tests.DataStructures
 {
@@ -16,7 +16,10 @@ public void Smoke_Test_DisJointSet()
             {
                 disjointSet.MakeSet(i);
             }
-         
+
+            //IEnumerable test
+            Assert.AreEqual(disjointSet.Count, disjointSet.Count());
+
             disjointSet.Union(1, 2);
             Assert.AreEqual(1, disjointSet.FindSet(2));
 
@@ -36,6 +39,9 @@ public void Smoke_Test_DisJointSet()
             disjointSet.Union(3, 4);
             Assert.AreEqual(1, disjointSet.FindSet(4));
 
+            //IEnumerable test
+            Assert.AreEqual(disjointSet.Count, disjointSet.Count());
+
         }
     }
 }

Advanced.Algorithms.Tests/DataStructures/Set/SparseSet_Tests.cs

@@ -17,10 +17,16 @@ public void SparseSet_Smoke_Test()
             set.Add(15);
             set.Add(0);
 
+            //IEnumerable test
+            Assert.AreEqual(set.Count, set.Count());
+
             set.Remove(15);
 
             Assert.IsTrue(set.HasItem(6));
-            Assert.AreEqual(2, set.Length);
+            Assert.AreEqual(2, set.Count);
+
+            //IEnumerable test
+            Assert.AreEqual(set.Count, set.Count());
         }
 
         [TestMethod]
@@ -38,6 +44,9 @@ public void SparseSet_Stress_Test()
                 set.Add(element);
             }
 
+            //IEnumerable test
+            Assert.AreEqual(set.Count, set.Count());
+
             foreach (var element in testCollection)
             {
                 Assert.IsTrue(set.HasItem(element));
@@ -49,6 +58,9 @@ public void SparseSet_Stress_Test()
                 set.Remove(element);
                 Assert.IsFalse(set.HasItem(element));
             }
+
+            //IEnumerable test
+            Assert.AreEqual(set.Count, set.Count());
         }
     }
 }

Advanced.Algorithms/DataStructures/Set/DisJointSet.cs

@@ -1,25 +1,34 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Advanced.Algorithms.DataStructures
 {
     /// <summary>
     /// A disjoint set implementation.
     /// </summary>
-    /// <typeparam name="T"></typeparam>
-    public class DisJointSet<T>
+    public class DisJointSet<T> : IEnumerable<T>
     {
         /// <summary>
         /// A Map for faster access for members.
         /// </summary>
         private Dictionary<T, DisJointSetNode<T>> set 
             = new Dictionary<T, DisJointSetNode<T>>();
 
+        public int Count { get; private set; }
+
         /// <summary>
         /// Creates a new set with given member.
+        /// Time complexity: log(n).
         /// </summary>
         public void MakeSet(T member)
         {
+            if (set.ContainsKey(member))
+            {
+                throw new Exception("A set with given member already exists.");
+            }
+
             var newSet = new DisJointSetNode<T>()
             {
                 Data = member,
@@ -28,13 +37,15 @@ public void MakeSet(T member)
 
             //Root's Parent is Root itself
             newSet.Parent = newSet;
-
             set.Add(member, newSet);
+
+            Count++;
         }
 
 
         /// <summary>
         /// Returns the reference member of the set where this member is part of.
+        /// Time complexity: log(n).
         /// </summary>
         public T FindSet(T member)
         {
@@ -48,9 +59,9 @@ public T FindSet(T member)
 
         /// <summary>
         /// Recursively move up in the set tree till root
-        /// And returns the Root (reference member)
-        /// Do Path Compression on all visited members on way to root
-        /// By pointing their parent to Root
+        /// and return the Root.
+        /// Does path Compression on all visited members on way to root
+        /// by pointing their parent to Root.
         /// </summary>
         private DisJointSetNode<T> FindSet(DisJointSetNode<T> node)
         {
@@ -68,8 +79,9 @@ private DisJointSetNode<T> FindSet(DisJointSetNode<T> node)
         }
 
         /// <summary>
-        /// Union's their sets if given members are in differant sets.
-        /// Otherwise do nothing.
+        /// Union's given member's sets if given members are in differant sets.
+        /// Otherwise does nothing.
+        /// Time complexity: log(n).
         /// </summary>
         public void Union(T memberA, T memberB)
         {
@@ -104,6 +116,17 @@ public void Union(T memberA, T memberB)
                 }
             }
         }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            return set.Values.Select(x => x.Data).GetEnumerator();
+        }
+      
     }
 
     internal class DisJointSetNode<T>

Advanced.Algorithms/DataStructures/Set/SparseSet.cs

@@ -1,24 +1,29 @@
 using System;
+using System.Collections;
+using System.Collections.Generic;
 using System.Linq;
 
 namespace Advanced.Algorithms.DataStructures
 {
     /// <summary>
     /// A sparse set implementation.
     /// </summary>
-    public class SparseSet
+    public class SparseSet : IEnumerable<int>
     {
         private readonly int[] sparse;
         private readonly int[] dense;
 
-        public int Length { get; private set; }
+        public int Count { get; private set; }
 
         public SparseSet(int maxVal, int capacity)
         {
             sparse = Enumerable.Repeat(-1, maxVal + 1).ToArray(); 
             dense = Enumerable.Repeat(-1, capacity).ToArray();
         }
 
+        /// <summary>
+        /// Time complexity: O(1).
+        /// </summary>
         public void Add(int value)
         {
             if (value < 0)
@@ -31,16 +36,19 @@ public void Add(int value)
                 throw new Exception("Item is greater than max value.");
             }
 
-            if (Length >= dense.Length)
+            if (Count >= dense.Length)
             {
                 throw new Exception("Set reached its capacity.");
             }
 
-            sparse[value] = Length;
-            dense[Length] = value;
-            Length++;
+            sparse[value] = Count;
+            dense[Count] = value;
+            Count++;
         }
 
+        /// <summary>
+        /// Time complexity: O(1).
+        /// </summary>
         public void Remove(int value)
         {
             if (value < 0)
@@ -63,25 +71,41 @@ public void Remove(int value)
             sparse[value] = -1;
 
             //replace index with last value of dense
-            var lastVal = dense[Length - 1];
+            var lastVal = dense[Count - 1];
             dense[index] = lastVal;
-            dense[Length - 1] = -1;
+            dense[Count - 1] = -1;
 
             //update sparse for lastVal
             sparse[lastVal] = index;
 
-            Length--;
+            Count--;
         }
 
+        /// <summary>
+        /// Time complexity: O(1).
+        /// </summary>
         public bool HasItem(int value)
         {
             var index = sparse[value];
             return index != -1 && dense[index] == value;
         }
 
+        /// <summary>
+        /// Time complexity: O(1).
+        /// </summary>
         public void Clear()
         {
-            Length = 0;
+            Count = 0;
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public IEnumerator<int> GetEnumerator()
+        {
+            return dense.Take(Count).GetEnumerator();
         }
     }
 }