SortedDictionary skeleton class.

Author: aalhour

DataStructures/DataStructures.csproj

@@ -91,6 +91,11 @@
     <Compile Include="Graphs\UnweightedEdge.cs" />
     <Compile Include="Graphs\IEdge.cs" />
     <Compile Include="SortedCollections\SortedList.cs" />
+    <Compile Include="SortedCollections\SortedDictionary.cs" />
+    <Compile Include="Trees\RedBlackTreeMap.cs" />
+    <Compile Include="Trees\RedBlackTreeMapNode.cs" />
+    <Compile Include="Trees\BinarySearchTreeMapNode.cs" />
+    <Compile Include="Trees\BinarySearchTreeMap.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. 

DataStructures/SortedCollections/SortedDictionary.cs

@@ -0,0 +1,143 @@
+using System;
+using System.Collections.Generic;
+
+using DataStructures.Common;
+using DataStructures.Trees;
+
+namespace DataStructures.SortedCollections
+{
+    /// <summary>
+    /// Sorted Dictionary collection (Red-Black Tree based).
+    /// </summary>
+    public class SortedDictionary<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>, IDictionary<TKey, TValue> 
+        where TKey : IComparable<TKey>
+    {
+        /// <summary>
+        /// The internal collection is a Red-Black Tree Map.
+        /// </summary>
+        private RedBlackTreeMap<TKey, TValue> _collection { get; set; }
+
+
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        public SortedDictionary()
+        {
+            _collection = new RedBlackTreeMap<TKey, TValue>(allowDuplicates: false);
+        }
+
+
+        /// <summary>
+        /// Gets the count of enteries in dictionary.
+        /// </summary>
+        public int Count
+        {
+            get { return _collection.Count; }
+        }
+
+        /// <summary>
+        /// Returns true if dictionary is empty; otherwise, false.
+        /// </summary>
+        public bool IsEmpty
+        {
+            get { return Count == 0; }
+        }
+
+        public bool IsReadOnly
+        {
+            get { return false; }
+        }
+
+        /// <summary>
+        /// Determines whether the current dictionary contains an entry with the specified key.
+        /// </summary>
+        public bool ContainsKey(TKey key)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool Contains(KeyValuePair<TKey, TValue> item)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Add(TKey key, TValue value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool Remove(TKey key)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool TryGetValue(TKey key, out TValue value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public TValue this[TKey index]
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+            set
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        public ICollection<TKey> Keys
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        public ICollection<TValue> Values
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        public void Add(KeyValuePair<TKey, TValue> item)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Clear()
+        {
+            _collection = new RedBlackTreeMap<TKey, TValue>(allowDuplicates: false);
+        }
+
+        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool Remove(KeyValuePair<TKey, TValue> item)
+        {
+            throw new NotImplementedException();
+        }
+
+
+        #region IEnumerable implementation
+
+        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
+        {
+            throw new NotImplementedException();
+        }
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+    }
+}
+

DataStructures/SortedCollections/SortedList.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Linq;
 using System.Collections.Generic;
 
 using DataStructures.Common;
@@ -29,31 +28,22 @@ public SortedList()
         /// <summary>
         /// Returns true if list is empty; otherwise, false.
         /// </summary>
-        public bool Empty
+        public bool IsEmpty
         {
-            get
-            {
-                return this.Count == 0;
-            }
+            get { return this.Count == 0; }
         }
 
         /// <summary>
         /// Gets the count of items in list.
         /// </summary>
         public int Count
         {
-            get
-            {
-                return this._collection.Count;
-            }
+            get { return this._collection.Count; }
         }
 
         public bool IsReadOnly
         {
-            get
-            {
-                return false;
-            }
+            get { return false; }
         }
 
         /// <summary>
@@ -96,6 +86,10 @@ public T this[int index]
         {
             get
             {
+                // In case list is empty
+                if (IsEmpty)
+                    throw new Exception("List is empty.");
+                
                 // Validate index range
                 if (index < 0 || index >= this.Count)
                     throw new IndexOutOfRangeException();