array stack implemetation

module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayQueue.java

@@ -5,28 +5,71 @@ import java.util.Iterator;
 import javax.annotation.Nonnull;
 
 public class ArrayQueue<E> extends Queue<E>{
+
+    private E[] queueArray = (E[]) new Object[1];
+    private int startPtr = 0;
+    private int endPtr = 0;
+
     @Override
     public boolean isEmpty() {
-        return false;
+        return startPtr >= endPtr;
     }
 
     @Override
     public E dequeue() {
-        return null;
+        if(isEmpty()){
+            return null;
+        }
+        E currentValue = queueArray[startPtr];
+        queueArray[startPtr++] = null;
+        if(size() < queueArray.length/4){
+            changeArraySize(queueArray.length/2);
+        }
+        return currentValue;
     }
 
     @Override
     public void enqueue(E element) {
-
+        queueArray[endPtr++] = element;
+        if(endPtr >= queueArray.length){
+            changeArraySize(queueArray.length*2);
+        }
     }
 
     @Override
     public int size() {
-        return 0;
+        return endPtr - startPtr;
     }
 
+    private void changeArraySize(int targetSize){
+        E[] tempArray = queueArray;
+        int oldArraySize = tempArray.length;
+        queueArray = (E[]) new Object[targetSize];
+        int j = 0;
+        for(int i=startPtr; i<endPtr; i++)
+            queueArray[j++]=tempArray[i];
+        endPtr = size();
+        startPtr = 0;
+    }
+
+    @Nonnull
     @Override
     public Iterator<E> iterator() {
-        return null;
+        return new QueueArrayIterator();
+    }
+
+    private class QueueArrayIterator implements Iterator<E>{
+
+        private int iteratorIndex = startPtr;
+
+        @Override
+        public boolean hasNext() {
+            return iteratorIndex<endPtr;
+        }
+
+        @Override
+        public E next() {
+            return queueArray[iteratorIndex++];
+        }
     }
 }

module4/src/main/java/com/hithomelabs/princeton1/module4/ArrayStack.java

@@ -5,28 +5,69 @@ import javax.annotation.Nonnull;
 // Concrete implementation of stack using arrays
 // Creating a generic stack of type E
 public class ArrayStack<E> extends Stack<E> {
+
+    E[] stackArray = (E[]) new Object[1];
+    private int index = 0;
+    private int arrayLength = stackArray.length;
+
     @Override
     public boolean isEmpty() {
-        return false;
+        return index == 0;
     }
 
     @Override
     public void push(E element) {
-
+        if(index == arrayLength){
+            changeArraySize(arrayLength*2);
+        }
+        stackArray[index] = element;
+        index++;
     }
 
     @Override
     public E pop() {
-        return null;
+        if(index == 0){
+            return null;
+        }
+        index--;
+        if(index < arrayLength/4){
+            changeArraySize(arrayLength/2);
+        }
+        E temp = stackArray[index];
+        stackArray[index] = null;
+        return temp;
     }
 
     @Override
     public int size() {
-        return 0;
+        return index;
     }
 
+    @Nonnull
     @Override
     public Iterator<E> iterator() {
-        return null;
+        return new StackIterator();
+    }
+
+    private void changeArraySize(int intendedSize){
+        E[] tempArray = stackArray;
+        int oldArraySize = stackArray.length;
+        stackArray = (E[]) new Object[intendedSize];
+        arrayLength = stackArray.length;
+        System.arraycopy(tempArray, 0, stackArray, 0, Math.min(oldArraySize, arrayLength));
+    }
+
+    private class StackIterator implements Iterator<E>{
+        private int iteratorIndex = 0;
+
+        @Override
+        public boolean hasNext() {
+            return stackArray[iteratorIndex] != null;
+        }
+
+        @Override
+        public E next() {
+            return stackArray[iteratorIndex++];
+        }
     }
 }

module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedQueue.java

@@ -4,28 +4,76 @@ import javax.annotation.Nonnull;
 import java.util.Iterator;
 
 public class LinkedQueue<E> extends Queue<E>{
+
+    Node<E> start = null;
+    Node<E> end = null;
+
+    static private class Node<E>{
+        E data;
+        Node<E> next;
+
+        private Node(E element){
+            data=element;
+            next=null;
+        }
+    }
+
     @Override
     public boolean isEmpty() {
-        return false;
+        return start == null;
     }
 
     @Override
     public E dequeue() {
-        return null;
+        if(isEmpty()) {
+            return null;
+        }
+        E currentValue = start.data;
+        start = start.next;
+        return currentValue;
     }
 
     @Override
     public void enqueue(E element) {
-
+        Node<E> new_node = new Node<E>(element);
+        if(isEmpty())
+            start = new_node;
+        else
+            end.next = new_node;
+        end = new_node;
     }
 
     @Override
     public int size() {
-        return 0;
+        int size = 0;
+        Node<E> sizePtr = start;
+        while (sizePtr != null) {
+            sizePtr = sizePtr.next;
+            size++;
+        }
+        return size;
     }
 
+    @Nonnull
     @Override
     public Iterator<E> iterator() {
-        return null;
+        return new LinkedQueueIterator();
+    }
+
+    private class LinkedQueueIterator implements Iterator<E>{
+
+        Node<E> traversePtr = start;
+
+        @Override
+        public boolean hasNext() {
+            return traversePtr != null;
+        }
+
+        @Override
+        public E next() {
+            E currentValue = traversePtr.data;
+            traversePtr = traversePtr.next;
+            return currentValue;
+        }
     }
 }

module4/src/main/java/com/hithomelabs/princeton1/module4/LinkedStack.java

@@ -1,30 +1,82 @@
 package com.hithomelabs.princeton1.module4;
+
+import javax.annotation.Nonnull;
 import java.util.Iterator;
 
 // Creating a concrete linked Implementation of Stack
 public class LinkedStack<E> extends Stack<E>{
+
+    static class Node<E>{
+        E data;
+        Node<E> next;
+
+        Node(E data) {
+            this.data = data;
+            this.next = null;
+        }
+    }
+
+    Node<E> head = null;
+    Node<E> endPtr = null;
+    int stackLength = 0;
+
     @Override
     public boolean isEmpty() {
-        return false;
+        return head == null;
     }
 
     @Override
     public void push(E element) {
-
+        Node<E> new_node = new Node<E>(element);
+        if(stackLength == 0)
+            head = new_node;
+        else
+            endPtr.next = new_node;
+        endPtr = new_node;
+        stackLength++;
     }
 
     @Override
     public E pop() {
-        return null;
+        if(stackLength == 0)
+            return null;
+        if(stackLength == 1)
+            head = null;
+        Node<E> secondLastPtr = head;
+        while(secondLastPtr!=null && secondLastPtr.next != endPtr && secondLastPtr.next!=null)
+            secondLastPtr = secondLastPtr.next;
+        E currentValue = endPtr.data;
+        endPtr.next = null;
+        endPtr = secondLastPtr;
+        stackLength--;
+        return currentValue;
     }
 
     @Override
     public int size() {
-        return 0;
+        return stackLength;
     }
 
+    @Nonnull
     @Override
     public Iterator<E> iterator() {
-        return null;
+        return new LinkedlistIterator();
+    }
+
+    private class LinkedlistIterator implements Iterator<E>{
+
+        Node<E> iteratorPtr = head;
+
+        @Override
+        public boolean hasNext() {
+            return iteratorPtr.next != null;
+        }
+
+        @Override
+        public E next() {
+            E currentValue = iteratorPtr.data;
+            iteratorPtr = iteratorPtr.next;
+            return currentValue;
+        }
     }
 }