implementato parzialmente la deque

com/xgiovio/QueueTest.java

@@ -1,7 +1,9 @@
 package com.xgiovio;
 
 import general_utility.test_object;
+import queue.ArrayQueue;
 import queue.ArrayQueueNoBlank;
+import queue.NodeQueue;
 
 /**
  * Created with xgiovio.macbookair.
@@ -17,23 +19,19 @@ public class QueueTest {
 
 
 
-    ArrayQueueNoBlank<test_object> queue = new ArrayQueueNoBlank<test_object>(5);
+    NodeQueue<test_object> queue = new NodeQueue<test_object>();
 
-        queue.enqueue(new test_object(1));
-        System.out.println(queue.front().get_data());
-        queue.enqueue(new test_object(1));
-        queue.enqueue(new test_object(1));
-        queue.enqueue(new test_object(1));
-        queue.enqueue(new test_object(1));
-        queue.enqueue(new test_object(1));
         queue.enqueue(new test_object(1));
         queue.enqueue(new test_object(1));
         queue.enqueue(new test_object(1));
         queue.enqueue(new test_object(5));
-        System.out.println(queue.front().get_data());
 
 
 
+
+
+        System.out.println(queue);
+
         System.out.println(queue.isEmpty());
         System.out.println(queue.size());
 

deque/Deque.java

@@ -0,0 +1,22 @@
+package deque;
+
+import exceptions.EmptyDequeException;
+
+/**
+ * Created with xgiovio.macbookair.
+ * User: xgiovio
+ * Date: 17/03/14
+ * Time: 16:21
+ */
+public interface Deque<E> {
+
+    int size();
+    boolean isEmpty();
+    E getFirst() throws EmptyDequeException;
+    E getLast() throws EmptyDequeException;
+    void addFirst (E element );
+    void addLast (E element);
+    E removeFirst() throws EmptyDequeException;
+    E removeLast() throws EmptyDequeException;
+
+}

deque/NodeDeque.java

@@ -0,0 +1,52 @@
+package deque;
+
+import exceptions.EmptyDequeException;
+
+/**
+ * Created with xgiovio.macbookair.
+ * User: xgiovio
+ * Date: 17/03/14
+ * Time: 16:26
+ */
+public class NodeDeque<E> implements Deque <E>  {
+
+    @Override
+    public int size() {
+        return 0;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return false;
+    }
+
+    @Override
+    public E getFirst() throws EmptyDequeException {
+        return null;
+    }
+
+    @Override
+    public E getLast() throws EmptyDequeException {
+        return null;
+    }
+
+    @Override
+    public void addFirst(E element) {
+
+    }
+
+    @Override
+    public void addLast(E element) {
+
+    }
+
+    @Override
+    public E removeFirst() throws EmptyDequeException {
+        return null;
+    }
+
+    @Override
+    public E removeLast() throws EmptyDequeException {
+        return null;
+    }
+}

deque/utility/DLNode.java

@@ -0,0 +1,10 @@
+package deque.utility;
+
+/**
+ * Created with xgiovio.macbookair.
+ * User: xgiovio
+ * Date: 17/03/14
+ * Time: 16:32
+ */
+public class DLNode {
+}

exceptions/EmptyDequeException.java

@@ -0,0 +1,14 @@
+package exceptions;
+
+/**
+ * Created with MONSTER.
+ * User: xgiovio
+ * Date: 05/03/14
+ * Time: 0.09
+ */
+public class EmptyDequeException extends RuntimeException {
+
+    public EmptyDequeException(){
+        super("Deque Empty");
+    }
+}

general_utility/test_object.java

@@ -16,6 +16,11 @@ public class test_object {
         return number;
     }
 
+    @Override
+    public String toString() {
+        return String.valueOf(number);
+    }
+
     private int number;
 
 }

queue/NodeQueue.java

@@ -0,0 +1,106 @@
+package queue;
+
+import exceptions.EmptyQueueException;
+import stack.utility.Node;
+
+import java.awt.image.AreaAveragingScaleFilter;
+
+/**
+ * Created with xgiovio.macbookair.
+ * User: xgiovio
+ * Date: 17/03/14
+ * Time: 14:08
+ */
+public class NodeQueue<E> implements Queue<E> {
+
+
+    @Override
+    public void enqueue(E element) {
+
+            Node<E> temp = new Node<E>(element,null);
+            if (rear == null){
+                rear = temp;
+            }else {
+                rear.setNext(temp);
+                rear = temp;
+            }
+            number_of_elements++;
+            if (number_of_elements == 1){
+                front = rear;
+            }
+
+    }
+
+    @Override
+    public E dequeue() throws EmptyQueueException {
+            if (isEmpty()){
+                throw new EmptyQueueException();
+            }else{
+               Node<E> temp = front;
+               front = front.getNext();
+               number_of_elements--;
+               if (number_of_elements == 0){
+                   rear = front;
+               }
+               return temp.getElement();
+            }
+    }
+
+    @Override
+    public E front() throws EmptyQueueException {
+        if (isEmpty()){
+            throw new EmptyQueueException();
+        } else{
+            return front.getElement();
+        }
+    }
+
+    @Override
+    public boolean isEmpty() {
+        if (number_of_elements == 0){
+            return true;
+        }else{
+            return false;
+        }
+    }
+
+    @Override
+    public boolean isFull() {
+        return false;
+    }
+
+    @Override
+    public int size() {
+        return number_of_elements;
+    }
+
+
+    @Override
+    public String toString() {
+        Node<E> temp;
+        String to_return = "";
+        if (!isEmpty()){
+            for (temp = front;temp != null;temp = temp.getNext()){
+                to_return+=temp.getElement();
+                if (temp.getNext() != null){
+                    to_return+=",";
+                }
+
+            }
+
+        }
+        return to_return;
+
+    }
+
+
+
+
+
+
+    private Node<E> front = null;
+    private Node<E> rear = null;
+    private int number_of_elements = 0;
+
+
+}