Add Queue-based Stack (TheAlgorithms#412)

Author: manish0x0f

DataStructures.Tests/Stack/QueueBasedStackTests.cs

@@ -0,0 +1,127 @@
+using DataStructures.Stack;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DataStructures.Tests.Stack
+{
+    public static class QueueBasedStackTests
+    {
+        [Test]
+        public static void PopWorksCorrectly()
+        {
+            //Arrange
+            QueueBasedStack<char> s = new QueueBasedStack<char>();
+            s.Push('A');
+            s.Push('B');
+            s.Push('C');
+            var result = new StringBuilder();
+
+            //Act
+            for (int i = 0; i < 3; i++)
+            {
+                result.Append(s.Pop());
+            }
+
+
+            //Assert
+            Assert.That("CBA", Is.EqualTo(result.ToString()));
+            Assert.IsTrue(s.IsEmpty(), "Stack is Empty");
+        }
+        [Test]
+        public static void PeekWorksCorrectly()
+        {
+            //Arrange
+            QueueBasedStack<int> s = new QueueBasedStack<int>();
+            s.Push(1);
+            s.Push(2);
+            s.Push(3);
+            var peeked = 0;
+
+            //Act
+            for (int i = 0; i < 3; i++)
+            {
+                peeked = s.Peek();
+            }
+
+
+            //Assert
+            Assert.That(3, Is.EqualTo(peeked));
+            Assert.IsFalse(s.IsEmpty(), "Stack is Empty");
+        }
+        [Test]
+        public static void PopEmptyStackThrowsInvalidOperationException()
+        {
+            //Arrange
+            var s = new QueueBasedStack<int>();
+            Exception? exception = null;
+
+            //Act
+            try
+            {
+                s.Pop();
+            }
+            catch (Exception ex)
+            {
+                exception = ex;
+            }
+
+            //Assert
+            Assert.That(exception?.GetType(), Is.EqualTo(typeof(InvalidOperationException)));
+        }
+        [Test]
+        public static void PeekEmptyStackThrowsInvalidOperationException()
+        {
+            //Arrange
+            var s = new QueueBasedStack<int>();
+            Exception? exception = null;
+
+            //Act
+            try
+            {
+                s.Peek();
+            }
+            catch (Exception ex)
+            {
+                exception = ex;
+            }
+
+            //Assert
+            Assert.That(exception?.GetType(), Is.EqualTo(typeof(InvalidOperationException)));
+        }
+        [Test]
+        public static void ClearWorksCorrectly()
+        {
+            // Arrange
+            var s = new QueueBasedStack<int>();
+            s.Push(1);
+            s.Push(2);
+
+            // Act
+            s.Clear();
+
+            // Assert
+            Assert.IsTrue(s.IsEmpty(), "Queue is empty");
+
+        }
+        [Test]
+        public static void LengthWorksCorrectly()
+        {
+            // Arrange
+            var s = new QueueBasedStack<int>();
+            s.Push(1);
+            s.Push(2);
+            var length = 0;
+
+            // Act
+            length = s.Length();
+
+            // Assert
+            Assert.That(2, Is.EqualTo(length));
+
+        }
+    }
+}

DataStructures/Stack/QueueBasedStack.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DataStructures.Stack
+{
+    public class QueueBasedStack<T>
+    {
+        private readonly Queue<T> queue;
+
+        public QueueBasedStack() => queue = new Queue<T>();
+
+        /// <summary>
+        ///     Clears the stack.
+        /// </summary>
+        public void Clear() => queue.Clear();
+
+        public bool IsEmpty() => queue.Count == 0;
+
+        /// <summary>
+        ///     Adds an item on top of the stack.
+        /// </summary>
+        /// <param name="item">Item to be added on top of stack.</param>
+        public void Push(T item) => queue.Enqueue(item);
+
+        /// <summary>
+        ///     Removes an item from  top of the stack and returns it.
+        ///  </summary>
+        /// <returns>item on top of stack.</returns>
+        /// <exception cref="InvalidOperationException">Throw if stack is empty.</exception>
+        public T Pop()
+        {
+            if (IsEmpty())
+            {
+                throw new InvalidOperationException("The stack contains no items.");
+            }
+
+            for (int i = 0; i < queue.Count - 1; i++)
+            {
+                queue.Enqueue(queue.Dequeue());
+            }
+
+            return queue.Dequeue();
+        }
+
+        /// <summary>
+        ///     return an item from the top of the stack without removing it.
+        /// </summary>
+        /// <returns>item on top of the stack.</returns>
+        /// <exception cref="InvalidOperationException">Throw if stack is empty.</exception>
+        public T Peek()
+        {
+            if (IsEmpty())
+            {
+                throw new InvalidOperationException("The stack contains no items.");
+            }
+
+            for (int i = 0; i < queue.Count - 1; i++)
+            {
+                queue.Enqueue(queue.Dequeue());
+            }
+
+            var item = queue.Peek();
+            queue.Enqueue(queue.Dequeue());
+            return item;
+        }
+
+        /// <summary>
+        ///     returns the count of items on the stack.
+        /// </summary>
+        /// <returns>number of items on the stack.</returns>
+        public int Length() => queue.Count;
+    }
+}

README.md

@@ -228,6 +228,7 @@ find more than one implementation for the same objective but using different alg
   * [Stack](./DataStructures/Stack)
     * [Array-based Stack](./DataStructures/Stack/ArrayBasedStack.cs)
     * [List-based Stack](./DataStructures/Stack/ListBasedStack.cs)
+    * [Queue-based Stack](./DataStructures/Stack/QueueBasedStack.cs)
   * [Heap](./DataStructures/Heap)
     * [Min-Max Heap](./DataStructures/Heap/MinMaxHeap.cs)
     * [Binary Heap](./DataStructures/Heap/BinaryHeap.cs)