build fix

Author: justcoding121

src/Advanced.Algorithms/Advanced.Algorithms.Docs.csproj

@@ -94,6 +94,10 @@
     <Compile Include="DataStructures\LinkedList\SinglyLinkedList.cs" />
     <Compile Include="DataStructures\List\ArrayList.cs" />
     <Compile Include="DataStructures\List\SkipList.cs" />
+    <Compile Include="DataStructures\Queues\ArrayQueue.cs" />
+    <Compile Include="DataStructures\Queues\LinkedListQueue.cs" />
+    <Compile Include="DataStructures\Queues\PriorityQueue.cs" />
+    <Compile Include="DataStructures\Queues\Queue.cs" />
     <Compile Include="DataStructures\Set\BloomFilter.cs" />
     <Compile Include="DataStructures\Set\DisJointSet.cs" />
     <Compile Include="DataStructures\Set\SparseSet.cs" />

src/Advanced.Algorithms/DataStructures/Queues/ArrayQueue.cs

@@ -0,0 +1,42 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Advanced.Algorithms.DataStructures.Foundation
+{
+    internal class ArrayQueue<T> : IQueue<T>
+    {
+        private readonly List<T> list = new List<T>();
+
+        public int Count { get; private set; }
+
+        public void Enqueue(T item)
+        {
+            list.Insert(0, item);
+            Count++;
+        }
+
+        public T Dequeue()
+        {
+            if (list.Count == 0)
+            {
+                throw new System.Exception("Empty Queue");
+            }
+
+            var result = list[list.Count - 1];
+            list.RemoveAt(list.Count - 1);
+            Count--;
+            return result;
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return list.GetEnumerator();
+        }
+    }
+
+}

src/Advanced.Algorithms/DataStructures/Queues/LinkedListQueue.cs

@@ -0,0 +1,40 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Advanced.Algorithms.DataStructures.Foundation
+{
+    internal class LinkedListQueue<T> : IQueue<T>
+    {
+        private readonly DoublyLinkedList<T> list = new DoublyLinkedList<T>();
+
+        public int Count { get; private set; }
+
+        public void Enqueue(T item)
+        {
+            list.InsertFirst(item);
+            Count++;
+        }
+
+        public T Dequeue()
+        {
+            if (list.Head == null)
+            {
+                throw new System.Exception("Empty Queue");
+            }
+
+            var result = list.DeleteLast();
+            Count--;
+            return result;
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return list.GetEnumerator();
+        }
+    }
+}

src/Advanced.Algorithms/DataStructures/Queues/PriorityQueue.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Advanced.Algorithms.DataStructures
+{
+    /// <summary>
+    /// A priority queue implementation using heap
+    /// </summary>
+    public class PriorityQueue<T> : IEnumerable<T> where T : IComparable
+    {
+        private readonly BHeap<T> heap;
+        public PriorityQueue(bool isMax = false)
+        {
+            heap = new BHeap<T>(isMax);
+        }
+
+        /// <summary>
+        /// Time complexity:O(log(n)).
+        /// </summary>
+        public void Enqueue(T item)
+        {
+            heap.Insert(item);
+        }
+
+        /// <summary>
+        /// Time complexity:O(log(n)).
+        /// </summary>
+        public T Dequeue()
+        {
+            return heap.Extract();
+        }
+
+        /// <summary>
+        /// Time complexity:O(1).
+        /// </summary>
+        public T Peek()
+        {
+            return heap.Peek();
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return heap.GetEnumerator();
+        }
+    }
+}

src/Advanced.Algorithms/DataStructures/Queues/Queue.cs

@@ -0,0 +1,74 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Advanced.Algorithms.DataStructures.Foundation
+{
+    /// <summary>
+    /// A queue implementation.
+    /// </summary>
+    public class Queue<T> : IEnumerable<T>
+    {
+        private readonly IQueue<T> queue;
+
+        /// <summary>
+        /// The number of items in the queue.
+        /// </summary>
+        public int Count => queue.Count;
+
+        /// <param name="type">The queue implementation type.</param>
+        public Queue(QueueType type = QueueType.Array)
+        {
+            if (type == QueueType.Array)
+            {
+                queue = new ArrayQueue<T>();
+            }
+            else
+            {
+                queue = new LinkedListQueue<T>();
+            }
+        }
+
+        /// <summary>
+        /// Time complexity:O(1).
+        /// </summary>
+        public void Enqueue(T item)
+        {
+            queue.Enqueue(item);
+        }
+
+        /// <summary>
+        /// Time complexity:O(1).
+        /// </summary>
+        public T Dequeue()
+        {
+            return queue.Dequeue();
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return queue.GetEnumerator();
+        }
+    }
+
+    internal interface IQueue<T> : IEnumerable<T>
+    {
+        int Count { get; }
+        void Enqueue(T item);
+        T Dequeue();
+    }
+
+    /// <summary>
+    /// The queue implementation types.
+    /// </summary>
+    public enum QueueType
+    {
+        Array = 0,
+        LinkedList = 1
+    }
+
+}