Fix bugs in Peek() and Pop() to throw an exception when stack is empty (#203)

Author: NageshAndani

DataStructures.Tests/ArrayBasedStackTests.cs

@@ -1,24 +1,28 @@
-using DataStructures.ArrayBasedStack;
+using System;
+
+using DataStructures.ArrayBasedStack;
 
 using NUnit.Framework;
 
 namespace DataStructures.Tests
 {
     public static class ArrayBasedStackTests
     {
+        const string StackEmptyErrorMessage = "Stack is empty";
+
         [Test]
         public static void CountTest()
         {
             var stack = new ArrayBasedStack<int>(new[] { 0, 1, 2, 3, 4 });
-            Assert.IsTrue(stack.Count == 5);
+            Assert.IsTrue(stack.Top == 4);
         }
 
         [Test]
         public static void ClearTest()
         {
             var stack = new ArrayBasedStack<int>(new[] { 0, 1, 2, 3, 4 });
             stack.Clear();
-            Assert.IsTrue(stack.Count == 0);
+            Assert.IsTrue(stack.Top == -1);
         }
 
         [Test]
@@ -80,5 +84,22 @@ public static void AutomaticResizesTest()
             stack.Push(4);
             Assert.IsTrue(stack.Capacity > 2);
         }
+
+        [Test]
+        public static void ShouldThrowStackEmptyExceptionOnEmptyPopTest()
+        {
+            var stack = new ArrayBasedStack<int>();
+
+            Assert.Catch(() => stack.Pop(), StackEmptyErrorMessage);
+        }
+
+        [Test]
+        public static void ShouldThrowStackEmptyExceptionOnEmptyPeekTest()
+        {
+            var stack = new ArrayBasedStack<int>();
+
+            Assert.Catch(() => stack.Peek(), StackEmptyErrorMessage);
+        }
+
     }
 }

DataStructures/ArrayBasedStack/ArrayBasedStack.cs

@@ -10,6 +10,7 @@ namespace DataStructures.ArrayBasedStack
     public class ArrayBasedStack<T>
     {
         private const int DefaultCapacity = 10;
+        private const string StackEmptyErrorMessage = "Stack is empty";
 
         /// <summary>
         /// <see cref="Array"/> based stack.
@@ -19,12 +20,16 @@ public class ArrayBasedStack<T>
         /// <summary>
         /// How many items are in the stack right now.
         /// </summary>
-        private int count;
+        private int top;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ArrayBasedStack{T}"/> class.
         /// </summary>
-        public ArrayBasedStack() => stack = new T[DefaultCapacity];
+        public ArrayBasedStack()
+        {
+            stack = new T[DefaultCapacity];
+            top = -1;
+        }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ArrayBasedStack{T}"/> class.
@@ -49,7 +54,7 @@ public ArrayBasedStack(IEnumerable<T> items)
         /// <summary>
         /// Gets the number of elements on the <see cref="ArrayBasedStack{T}"/>.
         /// </summary>
-        public int Count => count;
+        public int Top => top;
 
         /// <summary>
         /// Gets or sets the Capacity of the <see cref="ArrayBasedStack{T}"/>.
@@ -70,30 +75,45 @@ public int Capacity
         /// <summary>
         /// Removes all items from the <see cref="ArrayBasedStack{T}"/>.
         /// </summary>
-        public void Clear() => count = 0;
+        public void Clear()
+        {
+            top = -1;
+            Capacity = DefaultCapacity;
+        }
 
         /// <summary>
         /// Determines whether an element is in the <see cref="ArrayBasedStack{T}"/>.
         /// </summary>
         /// <param name="item">The item to locate in the <see cref="ArrayBasedStack{T}"/>.</param>
         /// <returns>True, if the item is in the stack.</returns>
-        public bool Contains(T item) => Array.IndexOf(stack, item, 0, count) > -1;
+        public bool Contains(T item) => Array.IndexOf(stack, item, 0, top + 1) > -1;
 
         /// <summary>
         /// Returns the item at the top of the <see cref="ArrayBasedStack{T}"/> without removing it.
         /// </summary>
         /// <returns>The item at the top of the <see cref="ArrayBasedStack{T}"/>.</returns>
-        public T Peek() => stack[count - 1];
+        public T Peek()
+        {
+            if (top == -1)
+            {
+                throw new InvalidOperationException(StackEmptyErrorMessage);
+            }
+
+            return stack[top];
+        }
 
         /// <summary>
         /// Removes and returns the item at the top of the <see cref="ArrayBasedStack{T}"/>.
         /// </summary>
         /// <returns>The item removed from the top of the <see cref="ArrayBasedStack{T}"/>.</returns>
         public T Pop()
         {
-            var item = stack[count - 1];
-            count = count - 1;
-            return item;
+            if (top == -1)
+            {
+                throw new InvalidOperationException(StackEmptyErrorMessage);
+            }
+
+            return stack[top--];
         }
 
         /// <summary>
@@ -102,13 +122,12 @@ public T Pop()
         /// <param name="item">The item to push onto the <see cref="ArrayBasedStack{T}"/>.</param>
         public void Push(T item)
         {
-            if (count == Capacity)
+            if (top == Capacity - 1)
             {
-                Capacity = Capacity * 2;
+                Capacity *= 2;
             }
 
-            stack[count] = item;
-            count = count + 1;
+            stack[++top] = item;
         }
     }
 }