Question

On Java:

Problems Problem 1. (Deque) Hints: my Use a doubly-linked list Node to implement the API — each node in the list stores a generic item, and references next and prev to the next and previous nodes in the list null itemi → item2 item3 ... itemn null Instance variables wy Reference to the front of the deque, Node first my Reference to the back of the deque, Node last my Size of the deque, int n + LinkedDeque () my Initialize instance variables to appropriate values boolean isEmpty() Return whether the deque is empty or not int size() my Return the size of the deque

Answer 1

Code For Above Problem:

Node Class Code:

public class Node<Item> {
        Item data;
        Node<Item> next;
        Node<Item> prev;

        public Node(Item data) {
                this.data = data;
                this.next = null;
                this.prev = null;
        }
}

LinkedDeque Class Code:

import java.util.Iterator;

public class LinkedDeque<Item> {
        // Instance variables
        Node<Item> first;// reference to the front of deque
        Node<Item> last;// reference to the back of the deque
        int n;// size of the deque

        /*
         * Constructor Initializes the instance variables to appropriate values
         */
        public LinkedDeque() {
                this.first = null;
                this.last = null;
                this.n = 0;
        }

        /*
         * Return whether Deque is empty or not
         */
        public boolean isEmpty() {
                return (n == 0);
        }

        /*
         * Returns Size of Deque
         */
        public int size() {
                return n;
        }

        /*
         * Add the given item to the front of the deque Increment n by one
         */
        public void addFirst(Item item) {
                Node<Item> newNode = new Node<Item>(item);
                if (isEmpty()) {
                        first = last = newNode;
                } else {
                        first.prev = newNode;
                        newNode.next = first;
                        first = newNode;
                }
                n++;
        }

        /*
         * Add the given item to the back of the deque Increment n by one
         */
        public void addLast(Item item) {
                Node<Item> newNode = new Node<Item>(item);
                if (isEmpty()) {
                        first = last = newNode;
                } else {
                        newNode.prev = last;
                        last.next = newNode;
                        last = newNode;
                }
                n++;
        }

        // Return the item at front of deque
        public Item peekFirst() {
                if (isEmpty()) {
                        throw new RuntimeException("Deque is empty");
                } else {
                        return first.data;
                }
        }

        // Remove and Return the item at front of deque
        public Item removeFirst() {
                if (isEmpty()) {
                        throw new RuntimeException("Deque is empty");
                }

                Node<Item> temp = first;
                if (first.next == null) {
                        last = null;
                } else {
                        first.next.prev = null;
                }
                first = first.next;
                n--;
                return temp.data;
        }

        // Return the item at the back of the deque
        public Item peekLast() {
                if (isEmpty()) {
                        throw new RuntimeException("Deque is empty");
                } else {
                        return last.data;
                }
        }

        // Remove and Return the item at the back of the deque
        public Item removeLast() {
                if (isEmpty()) {
                        throw new RuntimeException("Deque is empty");
                } else {
                        Node<Item> temp = last;
                        if (last.prev == null) {
                                first = null;
                        } else {
                                last.prev.next = null;
                        }
                        last = last.prev;
                        n--;
                        return temp.data;
                }
        }

        /*
         * Return an Object of type DequeIterator
         */
        public Iterator<Item> iterator() {
                return new DequeIterator();
        }

        class DequeIterator implements Iterator<Item> {

                // Instance variable
                // Reference to the current Node in the iterator
                Node<Item> current;

                /*
                 * initializes the instance variable appropiately
                 */
                public DequeIterator() {
                        this.current = first;
                }

                /*
                 * Return whether the iterator has more items to iterate or not
                 */
                public boolean hasNext() {
                        return (current != null);
                }

                /*
                 * Return the item in the current Node and advance current to the next node
                 */
                public Item next() {

                        Item data = current.data;
                        current = current.next;
                        return data;
                }
        }
}

Main Class Code:(Driver)/(Optional)

import java.util.Iterator;

public class Main {

        public static void main(String[] args) {

                // create new Object Of LinkedDeque
                LinkedDeque<String> q = new LinkedDeque<String>();
                // Check deque is empty or not
                System.out.println("Is Empty: " + q.isEmpty());
                // get the size of deque
                System.out.println("Size: " + q.size());
                // add values to front of deque
                q.addFirst("Three");
                q.addFirst("Two");
                q.addFirst("one");
                // add values to back of deque
                q.addLast("Four");
                q.addLast("Five");
                q.addLast("Six");

                // iterator to iterate all values in deque
                System.out.println("\nItems Of Deque are: ");
                Iterator<String> iter = q.iterator();
                while (iter.hasNext()) {
                        System.out.println(iter.next());
                }

                // get the fist item of deque
                System.out.println("\nFirst item is: " + q.peekFirst());
                // get the last value of deque
                System.out.println("Last item is: " + q.peekLast());
                // remove the first value of deque
                System.out.println("Removed item from first of deque is: " + q.removeFirst());
                // remove the last value of deque
                System.out.println("Removed item from last of deque is: " + q.removeLast());

                // iterator to iterate all values in deque
                System.out.println("\nItems Of Deque are: ");
                iter = q.iterator();
                while (iter.hasNext()) {
                        System.out.println(iter.next());
                }

                System.out.println("Size: " + q.size());
                System.out.println("Is Empty: " + q.isEmpty());
        }

}

Output Of Code:

Is Empty: true
Size: 0

Items Of Deque are: 
one
Two
Three
Four
Five
Six

First item is: one
Last item is: Six
Removed item from first of deque is: one
Removed item from last of deque is: Six

Items Of Deque are: 
Two
Three
Four
Five
Size: 4
Is Empty: false

Images Of Code:

Node Class Code:

public class Node<Item> { Item data; Node<Item> next; Node<Item> prev; public Node (Item data) { this.data = data; this.next = null; this.prev = null; } }

LinkedDeque Class Code:

4 6 11 */ 1 import java.util.Iterator; 2 3 public class LinkedDeque<Item> { // Instance variables 5 Node<Item> first;// reference to the front of deque Node<Item> last;// reference to the back of the deque 7 int n;// size of the deque 8 90 10 * Constructor Initializes the instance variables to appropriate values */ 120 public LinkedDeque() { 13 this first = null; 14 this. last = null; 15 this.n = 0; 16 } 17 186 19 * Return whether Deque is empty or not 20 210 public boolean isEmpty() { 22 return (n = 0); 23 } 24 250 /* 26 * Returns Size of Deque 27 280 public int size() { 29 return n; 30 } 31 320 33 * Add the given item to the front of the deque Increment n by one 34 */ 350 public void addFirst(Item item) { 36 Node<Item> newNode = new Node<Item>(item); 37 if (isEmpty()) { 38 first = last = newNode; 39 } else { 40 first.prev = newNode; 41 newNode.next = first; 42 first = newNode; 43 } 44 n++; 45 } 46

* Add the given item to the back of the deque Increment n by one */ public void addLast(Item item) { Node<Item> newNode = new Node<Item>(item); if (isEmpty()) { first = last = newlode; } else { newNode.prev = last; last.next = newNode; last = newNode; } n++; } 46 470 48 49 500 51 52 53 54 55 56 57 58 59 60 61 62 636 64 65 66 67 68 69 70 71 720 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 // Return the item at front of deque public Item peekFirst() { if (isEmpty()) { throw new RuntimeException("Deque is empty"); } else { return first.data; } } // Remove and Return the item at front of deque public Item removeFirst() { if (isEmpty()) { throw new RuntimeException("Deque is empty"); } Node<Item> temp = first; if (first.next == null) { last = null; } else { first.next.prev = null; } first = first.next; return temp.data; }

// Return the item at the back of the deque public Item peeklast() { if (isEmpty()) { throw new RuntimeException("Deque is empty"); } else { return last.data; } } 88 899 90 91 92 93 94 95 96 97 980 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 1140 115 116 1176 118 119 120 // Remove and Return the item at the back of the deque public Item removeLast() { if (isEmpty()) { throw new RuntimeException("Deque is empty"); } else { Node<Item> temp = last; if (last.prev == null) { first = null; } else { last.prev.next = null; } last = last.prev; return temp.data; } } /* * Return an object of type DequeIterator */ public Iterator<Item> iterator() { return new DequeIterator(); }

120 1210 122 123 class DequeIterator implements Iterator<Item> { // Instance variable // Reference to the current Node in the iterator Node<Item> current; 124 125 126 1270 128 129 1300 131 132 133 1340 initializes the instance variable appropiately public DequeIterator() { this.current = first; } 135 136 1370 138 139 140 1410 142 143 1440 145 146 147 148 149 150 151 } 152 * Return whether the iterator has more items to iterate or not public boolean hasNext() { return (current != null); } 1* Return the item in the current Node and advance current to the next node public Item next() { Item data = current.data; current = current.next; return data; } }

Main Class Code:(Driver)/(Optional)

6 7 8 1 import java.util. Iterator; 2 3 public class Main { 4 50 public static void main(String[] args) { // create new Object Of LinkedDeque LinkedDeque<String> q = new LinkedDeque<String>(); 9 // Check deque is empty or not 10 System.out.println("Is Empty: " + q.isEmpty(); // get the size of deque 12 System.out.println("Size: " + q.size()); 13 // add values to front of deque 14 q.addFirst("Three"); 15 q.addFirst("Two"); 16 q.addFirst("one"); 17 // add values to back of deque 18 q.addLast("Four"); 19 q.addLast("Five"); 20 q.addLast("Six"); 21 22 // iterator to iterate all values in deque 23 System.out.println("\nItems Of Deque are: "); 24 Iterator<String> iter = q. iterator(); 25 while (iter. hasNext()) 26 System.out.println(iter.next()); 27 } 28 29 // get the fist item of deque 30 System.out.println("\nFirst item is: " + q.peekFirst()); 31 // get the last value of deque 32 System.out.println("Last item is: " + q.peeklast()); 33 1/ remove the first value of deque 34 System.out.println("Removed item from first of deque is: + q.removeFirst()); 35 11 remove the last value of deque 36 System.out.println("Removed item from last of deque is: " + q.removeLast()); 37 38 // iterator to iterate all values in deque 39 System.out.println("\nItems Of Deque are: "); 40 iter = q. iterator(); 41 while (iter.hasNext()) { 42 System.out.println(iter.next()); 43 } System.out.println("Size: " + q.size()); 45 System.out.println("Is Empty: + q. isEmpty()); 46 } 47] 48

Output Of Code:

Is Empty: true Size: 0 Items Of Deque are: one TWO Three Four Five Six First item is: one Last item is: Six Removed item from first of deque is: one Removed item from last of deque is: Six Items Of Deque are: TWO Three Four Five Size: 4 Is Empty: false