Support buld operations for ring buffer

Author: justcoding121

Advanced.Algorithms.Tests/DataStructures/Queues/CircularQueue_Tests.cs

@@ -13,16 +13,16 @@ public void CircularQueue_Test()
         {
             var Queue = new CircularQueue<int>(7);
 
-            Queue.Enqueue(1);
-            Queue.Enqueue(2);
+            Assert.AreEqual(0, Queue.Enqueue(1));
+            Assert.AreEqual(0, Queue.Enqueue(2));
 
-            Queue.Enqueue(3);
-            Queue.Enqueue(4);
-            Queue.Enqueue(5);
-            Queue.Enqueue(6);
-            Queue.Enqueue(7);
-            Queue.Enqueue(8);
-            Queue.Enqueue(9);
+            Assert.AreEqual(0, Queue.Enqueue(3));
+            Assert.AreEqual(0, Queue.Enqueue(4));
+            Assert.AreEqual(0, Queue.Enqueue(5));
+            Assert.AreEqual(0, Queue.Enqueue(6));
+            Assert.AreEqual(0, Queue.Enqueue(7));
+            Assert.AreEqual(1, Queue.Enqueue(8));
+            Assert.AreEqual(2, Queue.Enqueue(9));
 
             Assert.AreEqual(Queue.Count, 7);
             Assert.AreEqual(3, Queue.Dequeue());
@@ -47,8 +47,8 @@ public void CircularQueue_Test()
 
             Assert.AreEqual(Queue.Count, 0);
 
-            Queue.Enqueue(1);
-            Queue.Enqueue(2);
+            Assert.AreEqual(0, Queue.Enqueue(1));
+            Assert.AreEqual(0, Queue.Enqueue(2));
 
             Assert.AreEqual(Queue.Count, 2);
             Assert.AreEqual(1, Queue.Dequeue());
@@ -57,6 +57,6 @@ public void CircularQueue_Test()
             Assert.AreEqual(Queue.Dequeue(), 2);
         }
 
- 
+
     }
-}
+}

Advanced.Algorithms/DataStructures/Queues/CircularQueue.cs

@@ -1,99 +1,148 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 
-namespace Advanced.Algorithms.DataStructures.Queues
+/// <summary>
+/// Cicular queue aka Ring Buffer using fixed size array
+/// </summary>
+/// <typeparam name="T"></typeparam>
+public class CircularQueue<T>
 {
+    private T[] queue;
+
+    //points to the index of next element to be deleted
+    private int start = 0;
+
+    //points to the index new element should be inserted
+    private int end = 0;
+
+    public int Count { get; private set; }
+
+    public CircularQueue(int size)
+    {
+        queue = new T[size];
+    }
+
     /// <summary>
-    /// Cicular queue aka Ring Buffer using fixed size array
+    /// Note: When buffer overflows oldest data will be erased
+    /// O(1) time complexity
     /// </summary>
-    /// <typeparam name="T"></typeparam>
-    public class CircularQueue<T>
+    /// <param name="data"></param>
+    public T Enqueue(T data)
     {
-        private T[] queue;
-
-        //points to the index of next element to be deleted
-        private int start = 0;
+        T deleted = default(T);
 
-        //points to the index new element should be inserted
-        private int end = 0;
+        //wrap around removing oldest element
+        if (end > queue.Length - 1)
+        {
+            end = 0;
 
-        public int Count { get; private set; }
+            if (start == 0)
+            {
+                deleted = queue[start];
+                start++;
+            }
+        }
 
-        public CircularQueue(int size)
+        //when end meets start after wraping around
+        if (end == start && Count > 1)
         {
-            queue = new T[size];
+            deleted = queue[start];
+            start++;
         }
 
-        /// <summary>
-        /// Note: When buffer overflows oldest data will be erased
-        /// </summary>
-        /// <param name="data"></param>
-        public void Enqueue(T data)
+        queue[end] = data;
+        end++;
+
+        if (Count < queue.Length)
         {
-            //wrap around removing oldest element
-            if (end > queue.Length - 1)
-            {
-                end = 0;
+            Count++;
+        }
 
-                if(start == 0)
-                {
-                    start++;
-                }
-            }
+        return deleted;
+    }
 
-            //when end meets start after wraping around
-            if (end == start && Count > 1)
-            {
-                start++;
-            }
+    /// <summary>
+    /// O(bulk.Length) time complexity
+    /// </summary>
+    /// <param name="bulk"></param>
+    /// <returns></returns>
+    public IEnumerable<T> Enqueue(T[] bulk)
+    {
+        var deletedList = new List<T>();
 
-            queue[end] = data;
-            end++;
+        foreach (var item in bulk)
+        {
+            var deleted = Enqueue(item);
 
-            if (Count < queue.Length)
+            if (!deleted.Equals(default(T)))
             {
-                Count++;
+                deletedList.Add(deleted);
             }
         }
 
+        return deletedList;
+    }
+
+    /// <summary>
+    /// O(1) time complexity
+    /// </summary>
+    /// <returns></returns>
+    public T Dequeue()
+    {
+        if (Count == 0)
+        {
+            throw new Exception("Empty queue.");
+        }
+
+        var element = queue[start];
+        start++;
 
-        public T Dequeue()
+        //wrap around 
+        if (start > queue.Length - 1)
         {
-            if (Count == 0)
+            start = 0;
+
+            if (end == 0)
             {
-                throw new Exception("Empty queue.");
+                end++;
             }
+        }
 
-            var element = queue[start];
-            start++;
+        Count--;
 
-            //wrap around 
-            if (start > queue.Length - 1)
-            {
-                start = 0;
+        if (start == end && Count > 1)
+        {
+            end++;
+        }
 
-                if (end == 0)
-                {
-                    end++;
-                }
-            }
+        //reset
+        if (Count == 0)
+        {
+            start = end = 0;
+        }
 
-            Count--;
+        return element;
+    }
 
-            if (start == end && Count > 1)
-            {
-                end++;
-            }
+    /// <summary>
+    /// O(bulkNumber) time complexity
+    /// </summary>
+    /// <param name="bulkNumber"></param>
+    public IEnumerable<T> Dequeue(int bulkNumber)
+    {
+        var deletedList = new List<T>();
+        while (bulkNumber > 0 && Count > 0)
+        {
+            var deleted = Dequeue();
 
-            //reset
-            if (Count == 0)
+            if (!deleted.Equals(default(T)))
             {
-                start = end = 0;
+                deletedList.Add(deleted);
             }
-
-            return element;
         }
+
+        return deletedList;
     }
+
 }
+