Add LinkedList implementation of Stack in the com.stacks package and also its testcase

Author: KAKANAKOU Miguel Stephane

Java-data-Structures/src/main/java/com/stacks/ArrayImplOfStack.java

@@ -12,12 +12,14 @@
  * the stack.
  *
  * {@link https://en.wikipedia.org/wiki/Stack_(abstract_data_type)}
+ * 
+ * This is a Resizing Array implementation of the Stack API
  *
  * @author STEPHANE MIGUEL KAKANAKOU (Skakanakou@gmail.com)
  *
  * @param <Item>
  */
-public class ArrayImplOfStack<Item> implements Stack<Item>, Iterable<Item> {
+public class ArrayImplOfStack<Item> implements Stack<Item> {
 
     /*** Contains the size of the stack. */
     private int arraySize;

Java-data-Structures/src/main/java/com/stacks/LinkedListImplOfStack.java

@@ -0,0 +1,151 @@
+package com.stacks;
+
+import java.util.Iterator;
+
+/**
+ * In computer science, a stack is an abstract data type that serves as a
+ * collection of elements, with two principal operations: push, which adds an
+ * element to the collection, and pop, which removes the most recently added
+ * element that was not yet removed. The order in which elements come off a
+ * stack gives rise to its alternative name, LIFO (for last in, first out).
+ * Additionally, a peek operation may give access to the top without modifying
+ * the stack.
+ *
+ * {@link https://en.wikipedia.org/wiki/Stack_(abstract_data_type)}
+ *
+ * This is a Linked List implementation of the Stack API
+ *
+ * @author STEPHANE MIGUEL KAKANAKOU (Skakanakou@gmail.com)
+ *
+ * @param <Item>
+ */
+public class LinkedListImplOfStack<Item> implements Stack<Item> {
+
+    /*
+     * Structure of each node of the linked list
+     */
+    private class Node {
+        Item item;
+        Node next;
+        public Node(Item item, Node next) {
+            this.item = item;
+            this.next = next;
+        }
+    }
+
+    /*** A reference to the Node on the top of the stack. */
+    private Node topStack;
+
+    /*** Contains the size of the stack. */
+    private int listSize;
+
+    /**
+     * Constructs an empty stack.
+     */
+    public LinkedListImplOfStack() {
+        this.listSize = 0;
+        this.topStack = null;
+    }
+
+    /*** {@inheritDoc} */
+    @Override
+    public Item pop() {
+        if (this.isEmpty()) {
+            throw new IllegalStateException("The stack is empty");
+        }
+        Item poppedItem = topStack.item;
+        topStack = topStack.next;
+        listSize--;
+        return poppedItem;
+    }
+
+    /*** {@inheritDoc} */
+    @Override
+    public Item peek() {
+        if (this.isEmpty()) {
+            throw new IllegalStateException("The stack is empty");
+        }
+        return topStack.item;
+    }
+
+    /*** {@inheritDoc} */
+    @Override
+    public void push(Item item) {
+        topStack = new Node(item, topStack);
+        listSize++;
+    }
+
+    /*** {@inheritDoc} */
+    @Override
+    public boolean isEmpty() {
+        if(topStack == null)
+            return true;
+        return false;
+    }
+
+    /*** {@inheritDoc} */
+    @Override
+    public void clear() {
+        topStack = null;
+        listSize = 0;
+    }
+
+    /*** {@inheritDoc} */
+    @Override
+    public int size() {
+        return listSize;
+    }
+
+    /*** {@inheritDoc} */
+    @Override
+    public boolean contains(Item item) {
+        Node top = topStack;
+        while (top != null) {
+            if (top.item.equals(item))
+                return true;
+            top = top.next;
+        }
+        return false;
+    }
+
+    /*** {@inheritDoc} */
+    @Override
+    public Iterator<Item> iterator() {
+        return new IteratorLinkedListImplOfStack();
+    }
+
+    /**
+     * IteratorLinkedListImplOfStack implements Iterator interface in order to
+     * provide iterable capabilities to the stack.
+     *
+     * @author STEPHANE MIGUEL KAKANAKOU (Skakanakou@gmail.com)
+     *
+     */
+    private class IteratorLinkedListImplOfStack implements Iterator<Item> {
+
+        /*** Reference on the current node in the iteration. */
+        private Node currentNode;
+
+        /*** Constructs IteratorLinkedListImplOfStack. */
+        public IteratorLinkedListImplOfStack() {
+            currentNode = topStack;
+        }
+
+        /*** {@inheritDoc} */
+        @Override
+        public boolean hasNext() {
+            if (currentNode != null)
+                return true;
+            return false;
+        }
+
+        /*** {@inheritDoc} */
+        @Override
+        public Item next() {
+            Item result = currentNode.item;
+            currentNode = currentNode.next;
+            return result;
+        }
+    }
+
+}

Java-data-Structures/src/main/java/com/stacks/Stack.java

@@ -15,7 +15,7 @@
  *
  * @param <Item>
  */
-public interface Stack<Item> {
+public interface Stack<Item> extends Iterable<Item>{
 
     /**
      * Removes and return the object at the top of this stack.

Java-data-Structures/src/test/java/com/test/stacks/TestArrayImplOfStack.java

@@ -6,6 +6,7 @@
 import junit.framework.TestCase;
 
 import com.stacks.ArrayImplOfStack;
+import com.stacks.Stack;
 
 /**
  * @author MacBook
@@ -14,7 +15,7 @@
 public class TestArrayImplOfStack extends TestCase{
 
     public void testStack() {
-        ArrayImplOfStack<String> stack = new ArrayImplOfStack<>(87);
+        Stack<String> stack = new ArrayImplOfStack<>(87);
         assertEquals(true, stack.isEmpty());
 
         // testing push

Java-data-Structures/src/test/java/com/test/stacks/TestLinkedListImplOfStack.java

@@ -0,0 +1,78 @@
+package com.test.stacks;
+
+
+import com.stacks.LinkedListImplOfStack;
+import com.stacks.Stack;
+
+import junit.framework.TestCase;
+
+public class TestLinkedListImplOfStack extends TestCase{
+
+    public void testStack() {
+        Stack<String> stack = new LinkedListImplOfStack<>();
+        assertEquals(true, stack.isEmpty());
+        
+        // testing push
+        stack.push("quick");
+        stack.push("brown");
+        stack.push("fox");
+        assertEquals(false, stack.isEmpty());
+        assertEquals(3, stack.size());
+        
+        stack.clear();
+        assertEquals(true, stack.isEmpty());
+        
+        stack.push("quick");
+        stack.push("brown");
+        stack.push("fox");
+        assertEquals(false, stack.isEmpty());
+        assertEquals(3, stack.size());
+        
+        // testing pop
+        assertEquals("fox", stack.pop());
+        assertEquals("brown", stack.pop());
+        assertEquals(1, stack.size());
+        assertEquals("quick", stack.pop());
+        assertEquals(true, stack.isEmpty());
+        assertEquals(0, stack.size());
+        
+        // testing peek
+        stack.clear();
+        stack.push("over");
+        stack.push("little");
+        stack.push("lazy");
+        stack.push("dog");
+        assertEquals("dog",stack.peek());       
+        assertEquals(4,  stack.size());     
+        stack.pop();
+        assertEquals("lazy",stack.peek());
+        
+        //testing Iterable
+        stack.clear();
+        stack.push("quick");
+        stack.push("brown");
+        stack.push("fox");
+        stack.push("over");
+        stack.push("little");
+        stack.push("lazy");
+        stack.push("dog");
+        
+        String[] expected = {"dog", "lazy", "little", "over", "fox", "brown", "quick"};
+        String[] result = new String[7];
+        int i=0;
+        for(String s : stack){
+            result[i] = s;
+            assertEquals(expected[i], result[i]);
+            i++;
+        }
+        
+        // testing underflow
+        try {
+            stack.pop();
+        } catch (IllegalStateException e) {
+            assertNotNull(e);
+        } catch (Exception e) {
+            assertNull(e);
+        }
+    }
+}