stack and queue implementation done

Author: Ram swaroop

src/me/ramswaroop/Main.java

@@ -1,8 +1,67 @@
 package me.ramswaroop;
 
+import me.ramswaroop.common.LinkedQueue;
+import me.ramswaroop.common.LinkedStack;
+
 public class Main {
 
     public static void main(String[] args) {
 	// write your code here
+
+        System.out.println("======== Stack ========");
+
+        LinkedStack<Integer> stack = new LinkedStack();
+        stack.push(5);
+        stack.push(7);
+        stack.push(2);
+        stack.push(6);
+        stack.print();
+        stack.pop();
+        stack.pop();
+        stack.pop();
+        stack.pop();
+        stack.print();
+        stack.push(1);
+        stack.push(2);
+        stack.print();
+        System.out.print(stack.peek());
+        stack.print();
+
+        System.out.println("\n======== Queue ========");
+
+        LinkedQueue<Integer> queue = new LinkedQueue();
+        queue.add(5);
+        queue.add(7);
+        queue.add(2);
+        queue.add(6);
+        queue.add(8);
+        queue.add(10);
+        queue.add(11);
+        queue.add(4);
+        queue.print();
+        queue.remove();
+        queue.remove();
+        queue.remove();
+        queue.print();
+        queue.remove();
+        queue.print();
+        queue.remove();
+        queue.remove();
+        queue.remove();
+        queue.remove();
+        queue.print();
+        //queue.remove();
+        //queue.remove();
+        queue.add(1);
+        queue.add(2);
+        queue.add(3);
+        queue.add(5);
+        queue.print();
+        queue.remove();
+        queue.remove();
+        queue.remove();
+        queue.print();
+        queue.remove();
+        queue.print();
     }
 }

src/me/ramswaroop/common/BinaryNode.java

@@ -0,0 +1,44 @@
+package me.ramswaroop.common;
+
+/**
+ * Created by IntelliJ IDEA.
+ * User: ramswaroop
+ * Date: 4/11/15
+ * Time: 7:11 PM
+ * To change this template go to Preferences | IDE Settings | File and Code Templates
+ */
+public class BinaryNode<E> {
+    E data;
+    BinaryNode left;
+    BinaryNode right;
+
+    public BinaryNode(E data, BinaryNode left, BinaryNode right) {
+        this.data = data;
+        this.left = left;
+        this.right = right;
+    }
+
+    public E getData() {
+        return data;
+    }
+
+    public void setData(E data) {
+        this.data = data;
+    }
+
+    public BinaryNode getLeft() {
+        return left;
+    }
+
+    public void setLeft(BinaryNode left) {
+        this.left = left;
+    }
+
+    public BinaryNode getRight() {
+        return right;
+    }
+
+    public void setRight(BinaryNode right) {
+        this.right = right;
+    }
+}

src/me/ramswaroop/common/interfaces/BinaryTree.java renamed to src/me/ramswaroop/common/BinarySearchTree.java

@@ -1,4 +1,4 @@
-package me.ramswaroop.common.interfaces;
+package me.ramswaroop.common;
 
 /**
  * Created by IntelliJ IDEA.
@@ -7,6 +7,6 @@
  * Time: 10:57 PM
  * To change this template go to Preferences | IDE Settings | File and Code Templates
  */
-public interface BinaryTree<T> extends Tree<T> {
+public interface BinarySearchTree<E> extends Tree<E> {
 
 }

src/me/ramswaroop/common/LinkedQueue.java

@@ -0,0 +1,89 @@
+package me.ramswaroop.common;
+
+import java.util.NoSuchElementException;
+
+/**
+ * Created by IntelliJ IDEA.
+ * User: ramswaroop
+ * Date: 4/12/15
+ * Time: 11:07 AM
+ * To change this template go to Preferences | IDE Settings | File and Code Templates
+ */
+public class LinkedQueue<E> implements Queue<E> {
+
+    Node<E> front;
+    Node<E> rear;
+
+    public LinkedQueue() {
+        front = null;
+        rear = null;
+    }
+
+    @Override
+    public E add(E item) {
+        if (front == null || rear == null) {
+            front = rear = new Node<>(item, null);
+        } else {
+            rear.next = new Node<>(item, null);
+            rear = rear.next;
+        }
+        return item;
+    }
+
+    @Override
+    public E remove() {
+        if (rear.next == front) {
+            throw new NoSuchElementException();
+        }
+        E item = element();
+        front = front.next;
+        return item;
+    }
+
+    @Override
+    public E element() {
+        if (front == null) {
+            throw new NoSuchElementException();
+        }
+        return front.data;
+    }
+
+    @Override
+    public int size() {
+        int count = 0;
+        if (rear.next == front) return count;
+        for (Node node = front; node != rear; node = node.next) {
+            count++;
+        }
+        return count;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return rear.next == front;
+    }
+
+    @Override
+    public void print() {
+        Node<E> node;
+        System.out.print("[");
+        if (rear.next == front) {
+            System.out.print("]");
+            return;
+        }
+        for (node = front; node != rear; node = node.next) {
+            System.out.print(node.data + ",");
+        }
+        System.out.print(node.data + "]");
+    }
+
+    private class Node<E> {
+        E data;
+        Node<E> next;
+
+        public Node(E data, Node<E> next) {
+            this.data = data;
+            this.next = next;
+        }
+    }
+}

src/me/ramswaroop/common/LinkedStack.java

@@ -1,9 +1,7 @@
 package me.ramswaroop.common;
 
 
-import me.ramswaroop.common.interfaces.Stack;
-
-import java.util.NoSuchElementException;
+import java.util.EmptyStackException;
 
 /**
  * Created by IntelliJ IDEA.
@@ -21,16 +19,21 @@
  */
 public class LinkedStack<E> implements Stack<E> {
 
-    private Node top = null;
+    private Node<E> top;
+
+    public LinkedStack() {
+        top = null;
+    }
 
     /**
      * Pushes an item onto the top of this stack.
      *
      * @param item
      */
     @Override
-    public void push(E item) {
-        top = new Node(item, top);
+    public E push(E item) {
+        top = new Node<>(item, top);
+        return item;
     }
 
     /**
@@ -53,7 +56,7 @@ public E pop() {
     @Override
     public E peek() {
         if (top == null) {
-            throw new NoSuchElementException();
+            throw new EmptyStackException();
         }
         return top.data;
     }
@@ -66,12 +69,29 @@ public E peek() {
     @Override
     public int size() {
         int count = 0;
-        for (Node node = top; node != null; node = top.next) {
+        for (Node node = top; node != null; node = node.next) {
             count++;
         }
         return count;
     }
 
+    /**
+     * Prints the content of the stack.
+     */
+    @Override
+    public void print() {
+        Node<E> node;
+        System.out.print("[");
+        if (top == null) {
+            System.out.print("]");
+            return;
+        }
+        for (node = top; node.next != null; node = node.next) {
+            System.out.print(node.data + ",");
+        }
+        System.out.print(node.data + "]");
+    }
+
     /**
      * Tests if this stack is empty.
      *
@@ -82,9 +102,9 @@ public boolean isEmpty() {
         return top == null;
     }
 
-    private class Node {
+    private class Node<E> {
         E data;
-        Node next;
+        Node<E> next;
 
         Node(E data, Node next) {
             this.data = data;

src/me/ramswaroop/common/Node.java

@@ -0,0 +1,63 @@
+package me.ramswaroop.common;
+
+/**
+ * Created by IntelliJ IDEA.
+ * User: ramswaroop
+ * Date: 4/12/15
+ * Time: 10:39 AM
+ * To change this template go to Preferences | IDE Settings | File and Code Templates
+ */
+public interface Queue<E> {
+
+
+    /**
+     * Inserts the specified element into this queue.
+     *
+     * @param item
+     * @return
+     */
+    public E add(E item);
+
+
+    /**
+     * Retrieves and removes the head of this queue. This method throws an
+     * exception if this queue is empty.
+     *
+     * @return
+     */
+    public E remove();
+
+
+    /**
+     * Retrieves, but does not remove, the head of this queue. This method throws an
+     * exception if this queue is empty.
+     *
+     * @return
+     */
+    public E element();
+
+
+    /**
+     * Returns the size of this queue.
+     *
+     * @return
+     */
+    public int size();
+
+
+    /**
+     * Tests whether the queue is empty or not.
+     *
+     * @return
+     */
+    public boolean isEmpty();
+
+
+    /**
+     * Prints the content of the queue.
+     *
+     */
+    public void print();
+
+
+}