assignment

assignments/AssigmentS6/LinkedDeque.java

@@ -0,0 +1,156 @@
+/**
+   A class that implements a deque of objects by using
+   a chain of doubly linked nodes.
+   @author Frank M. Carrano
+*/
+public final class LinkedDeque<T> implements DequeInterface<T>
+{
+    private DLNode firstNode; // References node at front of queue
+    private DLNode lastNode;  // References node at back of queue
+    
+    public LinkedDeque()
+    {
+        firstNode = null;
+        lastNode = null;
+    } // end default constructor
+    
+    /** Adds a new entry to the front/back of this deque.
+       @param newEntry  An object to be added. */
+    public void addToFront(T newEntry)
+    {        
+        DLNode newNode = new DLNode(null, newEntry, firstNode);
+        
+        if (isEmpty())
+            lastNode = newNode;
+        else
+            firstNode.setPreviousNode(newNode);
+        firstNode = newNode;
+    } // end addToFront
+    
+    public void addToBack(T newEntry)
+    {
+        DLNode newNode = new DLNode(lastNode, newEntry, null);
+        
+        if (isEmpty())
+            firstNode = newNode;
+        else
+            lastNode.setNextNode(newNode);
+        // end if
+        lastNode = newNode;        
+    } // end addToBack
+
+    /** Removes and returns the front/back entry of this deque.
+       @return  The object at the front/back of the deque.
+       @throws  EmptyQueueException if the deque is empty before the
+                operation. */
+    public T removeFront()
+    {
+        T front = getFront(); // Might throw an EmptyQueueException 
+        assert firstNode != null;
+        
+        firstNode = firstNode.getNextNode();
+        
+        if (firstNode == null)
+            lastNode = null;
+        else
+            firstNode.setPreviousNode(null);
+        return front;
+    } // end removeFront
+    
+    public T removeBack()
+    {
+        T back = getBack(); // Might throw an EmptyQueueException   
+        assert lastNode != null;
+        lastNode = lastNode.getPreviousNode();
+        
+        if (lastNode == null)
+            firstNode = null;
+        else
+            lastNode.setNextNode(null);
+        return back;        
+    } // end removeBack
+    
+    /** Retrieves the front/back entry of this deque.
+       @return  The object at the front/back of the deque.
+       @throws  EmptyQueueException if the deque is empty. */
+    public T getFront()
+    {
+        if (isEmpty())
+            throw new EmptyQueueException();
+        else
+            return firstNode.getData();
+    } // end getFront
+    
+    public T getBack()
+    {
+        if (isEmpty())
+            throw new EmptyQueueException();
+        else
+            return lastNode.getData();        
+    } // end getBack
+    
+    /** Detects whether this deque is empty.
+       @return  True if the deque is empty, or false otherwise. */
+    public boolean isEmpty()
+    {
+        return (firstNode == null && lastNode == null);
+    } // end isEmpty
+   
+    /* Removes all entries from this deque. */
+    public void clear()
+    {
+        firstNode = null;
+        lastNode = null;
+    } // end clear 
+    
+    // @author Frank M. Carrano, Timothy M. Henry
+    // @version 5.0 */
+    private class DLNode
+    {
+        private T    data;  // Entry in bag
+        private DLNode previous;  // Link to previous node
+        private DLNode next;  // Link to next node
+
+        private DLNode(T dataPortion)
+        {
+            this(null, dataPortion, null);
+        } // end constructor
+
+        private DLNode(DLNode previousDLNode, T dataPortion, DLNode nextDLNode)
+        {
+            data = dataPortion;
+            previous = previousDLNode;
+            next = nextDLNode;
+        } // end constructor
+
+        private T getData()
+        {
+            return data;
+        } // end getData
+
+        private void setData(T newData)
+        {
+            data = newData;
+        } // end setData
+
+        private DLNode getNextNode()
+        {
+            return next;
+        } // end getNextDLNode
+
+        private void setNextNode(DLNode nextDLNode)
+        {
+            next = nextDLNode;
+        } // end setNextDLNode
+        
+        private DLNode getPreviousNode()
+        {
+            return previous;
+        } // end getPreviousDLNode
+
+        private void setPreviousNode(DLNode previousDLNode)
+        {
+            previous = previousDLNode;
+        } // end setPreviousDLNode
+    } // end DLNode
+} // end LinkedQueue