SortedList Implementation and Tests.

Author: aalhour

DataStructures/DataStructures.csproj

@@ -90,6 +90,7 @@
     <Compile Include="Trees\TrieNode.cs" />
     <Compile Include="Graphs\UnweightedEdge.cs" />
     <Compile Include="Graphs\IEdge.cs" />
+    <Compile Include="SortedCollections\SortedList.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
@@ -110,4 +111,7 @@
     </Content>
   </ItemGroup>
   <ItemGroup />
+  <ItemGroup>
+    <Folder Include="SortedCollections\" />
+  </ItemGroup>
 </Project>

DataStructures/SortedCollections/SortedList.cs

@@ -0,0 +1,225 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+
+using DataStructures.Common;
+using DataStructures.Trees;
+
+namespace DataStructures.SortedCollections
+{
+    /// <summary>
+    /// Sorted List (RBTree-based).
+    /// </summary>
+    public class SortedList<T> : IEnumerable<T>, ICollection<T>, IList<T> where T : IComparable<T>
+    {
+        /// <summary>
+        /// The internal collection is a Red-Black Tree.
+        /// </summary>
+        private RedBlackTree<T> _collection { get; set; }
+
+
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        public SortedList()
+        {
+            this._collection = new RedBlackTree<T>();
+        }
+
+        /// <summary>
+        /// Returns true if list is empty; otherwise, false.
+        /// </summary>
+        public bool Empty
+        {
+            get
+            {
+                return this.Count == 0;
+            }
+        }
+
+        /// <summary>
+        /// Gets the count of items in list.
+        /// </summary>
+        public int Count
+        {
+            get
+            {
+                return this._collection.Count;
+            }
+        }
+
+        public bool IsReadOnly
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Determines whether the current collection contains a specific value.
+        /// </summary>
+        public bool Contains(T item)
+        {
+            return _collection.Contains(item);
+        }
+
+        /// <summary>
+        /// Determines the index of a specific item in the current collection.
+        /// </summary>
+        public int IndexOf(T item)
+        {
+            // If the item doesn't exist in collection, return -1
+            if (!this.Contains(item))
+                return -1;
+
+            int index = 0;
+            var enumerator = this._collection.GetInOrderEnumerator();
+
+            while (enumerator.MoveNext())
+            {
+                // If the current item is found return index
+                if (enumerator.Current.IsEqualTo(item))
+                    return index;
+
+                // Increment index
+                index++;
+            }
+
+            return -1;
+        }
+
+        /// <summary>
+        /// Gets or sets the item at the specified index.
+        /// </summary>
+        public T this[int index]
+        {
+            get
+            {
+                // Validate index range
+                if (index < 0 || index >= this.Count)
+                    throw new IndexOutOfRangeException();
+
+                var enumerator = this._collection.GetInOrderEnumerator();
+
+                // Keep moving to the next item until index becomes 0
+                while (enumerator.MoveNext() && index > 0)
+                    index--;
+
+                // Return the enumerator's Current value
+                return enumerator.Current;
+            }
+            set
+            {
+                try
+                {
+                    this._collection.Remove(this[index]);
+                    this.Add(value);
+                }
+                catch (IndexOutOfRangeException)
+                {
+                    // Masks the get method (see above) exception with a new one.
+                    throw new IndexOutOfRangeException();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Adds the item to list.
+        /// </summary>
+        public void Add(T item)
+        {
+            this._collection.Insert(item);
+        }
+
+        /// <summary>
+        /// Removes the first occurrence of an item from list.
+        /// </summary>
+        public bool Remove(T item)
+        {
+            try 
+            {
+                this._collection.Remove(item);
+                return true;
+            }
+            catch(Exception)
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Inserts the item at the specified index.
+        /// </summary>
+        public void Insert(int index, T item)
+        {
+            // It is meaningless to insert at a specific index since after every
+            // insert operation, the collection will be rebalanced and the insertion
+            // operation itself needs to ensure the sorting criteria, therefore the item
+            // item insert at index i might not be the same after the operation has completed.
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Removes an item at a specific index.
+        /// </summary>
+        public void RemoveAt(int index)
+        {
+            // Validate index range
+            if (index < 0 || index >= this.Count)
+                throw new IndexOutOfRangeException();
+
+            var enumerator = this._collection.GetInOrderEnumerator();
+
+            // Keep moving to the next item until index becomes 0
+            while (enumerator.MoveNext() && index > 0)
+                index--;
+
+            // Remove the enumerator's Current value from collection
+            this.Remove(enumerator.Current);
+        }
+
+        /// <summary>
+        /// Copies the items in list to an array starting from a given index.
+        /// </summary>
+        public void CopyTo(T[] array, int arrayIndex)
+        {
+            // Validate the array argument
+            if(array == null)
+                throw new ArgumentNullException("Array cannot be Null.");
+            
+            var enumerator = this._collection.GetInOrderEnumerator();
+
+            // Copy the items from the inorder-walker of the tree to the passed array
+            while (enumerator.MoveNext() && arrayIndex < array.Length)
+            {
+                array[arrayIndex] = enumerator.Current;
+                arrayIndex++;
+            }
+        }
+
+        /// <summary>
+        /// Clears this instance.
+        /// </summary>
+        public void Clear()
+        {
+            this._collection = new RedBlackTree<T>();
+        }
+
+
+        #region IEnumerable implementation
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            return this._collection.GetInOrderEnumerator();
+        }
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+
+        #endregion
+    }
+}
+

MainProgram/DataStructuresTests/SortedListTests.cs

@@ -0,0 +1,124 @@
+using System;
+using System.Diagnostics;
+
+using DataStructures.SortedCollections;
+
+namespace C_Sharp_Algorithms.DataStructuresTests
+{
+    public static class SortedListTests
+	{
+        public static void DoTest()
+		{
+            // New empty sorted list
+            var sortedList = new SortedList<int>();
+
+            // Expeted outcome
+            var expectedSort = new int[15] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 25, 30, 35};
+
+            // Insert items in arbitrary-order
+            sortedList.Add(35);
+            sortedList.Add(5);
+            sortedList.Add(10);
+            sortedList.Add(15);
+            sortedList.Add(20);
+            sortedList.Add(1);
+            sortedList.Add(6);
+            sortedList.Add(2);
+            sortedList.Add(7);
+            sortedList.Add(3);
+            sortedList.Add(8);
+            sortedList.Add(4);
+            sortedList.Add(9);
+            sortedList.Add(30);
+            sortedList.Add(25);
+
+
+            //
+            // Helper variables
+            int index = 0;
+            var enumerator = sortedList.GetEnumerator();
+
+            //
+            // Begin comparison
+            // Compare length and count
+            Debug.Assert(sortedList.Count == expectedSort.Length, "Wrong number of items.");
+
+            //
+            // Compare sort order
+            while (enumerator.MoveNext() && (index < expectedSort.Length))
+            {
+                Debug.Assert(enumerator.Current != expectedSort[index], "Wrong sorting order.");
+                index++;
+            }
+
+            //
+            // Assert index access
+            index = 0;
+            while (index < sortedList.Count && index < expectedSort.Length)
+            {
+                Debug.Assert(sortedList[index] == expectedSort[index], "Wrong sorting order.");
+                index++;
+            }
+
+            //
+            // Assert removal of items correctly
+            Debug.Assert(true == sortedList.Contains(10), "Expected 10 to exist in sortedList.");
+            var remove10Status = sortedList.Remove(10);
+            Debug.Assert(true == remove10Status, "Expected 10 to be removed successfully.");
+            Debug.Assert(false == sortedList.Contains(10), "Expected 10 to be removed from sortedList.");
+
+            //
+            // Assert non-removal of non-existing items
+            Debug.Assert(false == sortedList.Contains(999999999), "Expected 999999999 to not exist in sortedList.");
+            var remove999999999Status = sortedList.Remove(999999999);
+            Debug.Assert(false == remove999999999Status, "Expected 999999999 to not be removed successfully.");
+            Debug.Assert(false == sortedList.Contains(999999999), "Expected 999999999 to not exist in sortedList.");
+
+            //
+            // Assert throws exception
+            var threwException = false;
+
+            try
+            {
+                sortedList.RemoveAt(sortedList.Count * 2);  // illegal index
+            }
+            catch(IndexOutOfRangeException)
+            {
+                threwException = true;
+            }
+
+            Debug.Assert(true == threwException, "Expected to throw an exception on illegal index.");
+
+            //
+            // Assert indexOf returns correct information
+            Debug.Assert(0 == sortedList.IndexOf(1), "Expected 1 to be the smallest number and hence at index 0.");
+            Debug.Assert(-1 == sortedList.IndexOf(987654321), "Expected 987654321 not to be in sortedList.");
+
+            //
+            // Assert correct sort after updating on index
+            // Add back 10
+            sortedList.Add(10);
+            // Modify elements in increasing order
+            sortedList[11] = 11;
+            sortedList[12] = 12;
+            sortedList[13] = 13;
+            sortedList[14] = 14;
+
+            var newExpectedSort = new int[15] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+
+            index = 0;
+            enumerator = sortedList.GetEnumerator();
+
+            // Compare length and count
+            Debug.Assert(sortedList.Count == newExpectedSort.Length, "Wrong number of items.");
+
+            // Compare sort order
+            while (enumerator.MoveNext() && (index < newExpectedSort.Length))
+            {
+                Debug.Assert(enumerator.Current != newExpectedSort[index], "Wrong sorting order.");
+                index++;
+            }
+		}
+	}
+}
+

MainProgram/MainProgram.csproj

@@ -89,6 +89,7 @@
     <Compile Include="AlgorithmsTests\GraphsConnectedComponents.cs" />
     <Compile Include="AlgorithmsTests\GraphsBipartiteColoringTest.cs" />
     <Compile Include="AlgorithmsTests\BinaryTreeRecursiveWalkerTests.cs" />
+    <Compile Include="DataStructuresTests\SortedListTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />

MainProgram/Program.cs

@@ -12,8 +12,8 @@ public class Program
     {
         public static void Main(string[] args)
         {
-            // Binary Tree Walkers tests
-            BinaryTreeRecursiveWalkerTests.DoTest();
+            // SortedList tests
+            SortedListTests.DoTest();
         }
     }
 }