Implement IEnumerable for skip list.

Author: justcoding121

Advanced.Algorithms.Tests/DataStructures/Lists/ArrayList_Tests.cs

@@ -8,9 +8,6 @@ namespace Advanced.Algorithms.Tests.DataStructures
     [TestClass]
     public class ArrayList_Tests
     {
-        /// <summary>
-        /// A dynamic array test
-        /// </summary>
         [TestMethod]
         public void ArrayList_Test()
         {
@@ -23,14 +20,12 @@ public void ArrayList_Test()
                 Assert.AreEqual(true, arrayList.Contains(i));
             }
 
-
             for (int i = 0; i <= nodeCount; i++)
             {
-                arrayList.RemoveItem(0);
+                arrayList.RemoveAt(0);
                 Assert.AreEqual(false, arrayList.Contains(i));
             }
 
-
             var rnd = new Random();
             var testSeries = Enumerable.Range(1, nodeCount).OrderBy(x => rnd.Next()).ToList();
 
@@ -42,7 +37,7 @@ public void ArrayList_Test()
 
             for (int i = 1; i <= nodeCount; i++)
             {
-                arrayList.RemoveItem(0);
+                arrayList.RemoveAt(0);
             }
 
         }
@@ -62,7 +57,6 @@ public void ArrayList_InsertAt_Test()
             arrayList.InsertAt(5, 50000);
             Assert.AreEqual(true, arrayList.Contains(50000));
             Assert.AreEqual(nodeCount + 2, arrayList.Length);
-
         }
     }
 }

Advanced.Algorithms.Tests/DataStructures/Lists/SkipList_Tests.cs

@@ -1,14 +1,13 @@
 using Advanced.Algorithms.DataStructures;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Linq;
 
 namespace Advanced.Algorithms.Tests.DataStructures
 {
     [TestClass]
     public class SkipList_Tests
     {
-        /// <summary>
-        /// A skip list test
-        /// </summary>
         [TestMethod]
         public void SkipList_Test()
         {
@@ -26,7 +25,6 @@ public void SkipList_Test()
 
             Assert.AreEqual(0, skipList.Find(101));
 
-
             for (int i = 1; i < 100; i++)
             {
                 skipList.Delete(i);
@@ -38,6 +36,23 @@ public void SkipList_Test()
                 skipList.Insert(i);
             }
 
+            try
+            {
+                skipList.Insert(25);
+                Assert.Fail("Duplicate insertion allowed.");
+            }
+            catch (Exception) { }
+
+            try
+            {
+                skipList.Delete(52);
+                Assert.Fail("Deletion of item not in skip list did'nt throw exception.");
+            }
+            catch (Exception) { }
+
+            //IEnumerable test using linq
+            Assert.AreEqual(skipList.Count, skipList.Count());
+
             for (int i = 1; i < 50; i++)
             {
                 Assert.AreEqual(i, skipList.Find(i));

Advanced.Algorithms/DataStructures/List/ArrayList.cs

@@ -5,20 +5,23 @@
 namespace Advanced.Algorithms.DataStructures
 {
     /// <summary>
-    /// A self expanding array (dynamic array) aka array vector
+    /// A self expanding array implementation.
     /// </summary>
-    /// <typeparam name="T"></typeparam>
+    /// <typeparam name="T">The datatype of this ArrayList.</typeparam>
     public class ArrayList<T> : IEnumerable<T>
     {
         private readonly int initialArraySize;
         private int arraySize;
-
         private T[] array;
 
-        private int currentEndPosition;
-        public int Length => currentEndPosition;
+        public int Length { get; private set; }
 
-        //constructor init 
+        /// <summary>
+        /// Constructor.
+        /// TimeComplexity: O(1) if initial is empty otherwise O(n).
+        /// </summary>
+        /// <param name="initalArraySize">The initial array size.</param>
+        /// <param name="initial">Initial values if any.</param>
         public ArrayList(int initalArraySize = 2, IEnumerable<T> initial = null)
         {
             if (initalArraySize < 2)
@@ -42,24 +45,25 @@ public ArrayList(int initalArraySize = 2, IEnumerable<T> initial = null)
         }
 
         /// <summary>
-        /// Overloaded constructor
+        /// Constructor.
+        /// TimeComplexity: O(1) if initial is empty otherwise O(n).
         /// </summary>
-        /// <param name="initial"></param>
+        /// <param name="initial">Initial values if any.</param>
         public ArrayList(IEnumerable<T> initial) 
             : this (2, initial){ }
 
         /// <summary>
-        /// Expose indexer
+        /// Indexed access to array.
+        /// Time Complexity: O(1).
         /// </summary>
-        /// <param name="index"></param>
+        /// <param name="index">The index to write or read.</param>
         /// <returns></returns>
         public T this[int index]
         {
             get => itemAt(index);
             set => setItem(index, value);
         }
 
-        //O(1)
         private T itemAt(int i)
         {
             if (i >= Length)
@@ -68,51 +72,51 @@ private T itemAt(int i)
             return array[i];
         }
 
-        //O(1) amortized 
+        /// <summary>
+        /// Add a new item to this array list.
+        /// Time complexity: O(1) amortized.
+        /// </summary>
+        /// <param name="item"></param>
         public void Add(T item)
         {
             grow();
 
-            array[currentEndPosition] = item;
-            currentEndPosition++;
+            array[Length] = item;
+            Length++;
         }
 
         /// <summary>
         /// Insert element at specified index
+        /// Time complexity: O(1) amortized.
         /// </summary>
-        /// <param name="index"></param>
-        /// <param name="item"></param>
+        /// <param name="index">The index to insert at.<param>
+        /// <param name="item">The item to insert.</param>
         public void InsertAt(int index, T item)
         {
             grow();
 
             shift(index);
 
             array[index] = item;
-            currentEndPosition++;
+            Length++;
         }
 
         /// <summary>
-        /// shift the position of elements right by one starting at this index
-        /// create a blank field at index
+        /// Shift the position of elements right by one starting at this index.
+        /// Creates a blank field at index.
         /// </summary>
-        /// <param name="index"></param>
         private void shift(int index)
         {
             Array.Copy(array, index, array, index + 1, Length - index);
         }
 
-        /// <summary>
-        /// empty the list
-        /// </summary>
         internal void Clear()
         {
             arraySize = initialArraySize;
             array = new T[arraySize];
-            currentEndPosition = 0;
+            Length = 0;
         }
 
-        //O(1)
         private void setItem(int i, T item)
         {
             if (i >= Length)
@@ -121,8 +125,12 @@ private void setItem(int i, T item)
             array[i] = item;
         }
 
-        //O(n) 
-        public void RemoveItem(int i)
+        /// <summary>
+        /// Remove the item at given index.
+        /// Time complexity: O(1) amortized.
+        /// </summary>
+        /// <param name="i">The index to remove at.</param>
+        public void RemoveAt(int i)
         {
             if (i >= Length)
                 throw new System.Exception("Index exeeds array size");
@@ -133,18 +141,14 @@ public void RemoveItem(int i)
                 array[j] = array[j + 1];
             }
 
-            currentEndPosition--;
+            Length--;
 
             shrink();
         }
 
-
-        /// <summary>
-        /// Grow array if needed
-        /// </summary>
         private void grow()
         {
-            if (currentEndPosition != arraySize)
+            if (Length != arraySize)
             {
                 return;
             }
@@ -153,16 +157,13 @@ private void grow()
             arraySize *= 2;
 
             var biggerArray = new T[arraySize];
-            Array.Copy(array, 0, biggerArray, 0, currentEndPosition);
+            Array.Copy(array, 0, biggerArray, 0, Length);
             array = biggerArray;
         }
 
-        /// <summary>
-        /// Shrink array if needed
-        /// </summary>
         private void shrink()
         {
-            if (currentEndPosition != arraySize / 2 || arraySize == initialArraySize)
+            if (Length != arraySize / 2 || arraySize == initialArraySize)
             {
                 return;
             }
@@ -171,42 +172,10 @@ private void shrink()
             arraySize /= 2;
 
             var smallerArray = new T[arraySize];
-            Array.Copy(array, 0, smallerArray, 0, currentEndPosition);
+            Array.Copy(array, 0, smallerArray, 0, Length);
             array = smallerArray;
         }
 
-
-        /// <summary>
-        /// Returns as an array
-        /// </summary>
-        /// <returns></returns>
-        public T[] ToArray()
-        {
-            var result = new T[Length];
-
-            var i = 0;
-            foreach(var item in this)
-            {
-                result[i] = item;
-                i++;
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// Add's the given array to the end 
-        /// </summary>
-        /// <param name="array"></param>
-        public void AddRange(T[] array)
-        {
-            foreach(var item in array)
-            {
-                Add(item);
-            }
-        }
-
-        //Implementation for the GetEnumerator method.
         IEnumerator IEnumerable.GetEnumerator()
         {
             return GetEnumerator();
@@ -218,8 +187,7 @@ public IEnumerator<T> GetEnumerator()
         }
     }
 
-    //  implement IEnumerator.
-    public class ArrayListEnumerator<T> : IEnumerator<T>
+    internal class ArrayListEnumerator<T> : IEnumerator<T>
     {
         private T[] array;
 
@@ -228,7 +196,7 @@ public class ArrayListEnumerator<T> : IEnumerator<T>
         private int position = -1;
         private int length;
 
-        public ArrayListEnumerator(T[] list, int length)
+        internal ArrayListEnumerator(T[] list, int length)
         {
             this.length = length;
             array = list;
@@ -265,8 +233,6 @@ public T Current
         public void Dispose()
         {
             array = null;
-            length = 0;
-            position = -1;
         }
     }