AlgorithmsI PA2: Randomized Queues and Deques Deque

本次作业考察利用array 或者linked list 实现规定时间复杂度的queue 和stack， 不能使用java 自带的stack 和queue. 目的是让我们掌握自己设计的函数的复杂度。

Deque成功的关键是

1. 选择合适的数据结构，本题选择doubly LinkedList.

2. 自己写测试代码，测试各种情况。addLast, removeFirst 等等，尤其注意边界情况。

Java code:

//Deque - should be implemented using a doubly linked list
import edu.princeton.cs.algs4.StdIn;
import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdRandom;
import java.util.Iterator;
import java.util.NoSuchElementException;

/*The goal of this assignment is to implement data types from first principles,
 *using resizing arrays and linked lists.
*/
/*
 * A double-ended queue or deque (pronounced "deck") is a generalization of a stack and a queue that
 * supports adding and removing items from either the front or the back of the data structure.
 *
 * Performance requirements.
 * Your deque implementation must support each deque operation in constant worst-case time.
 * A deque containing N items must use at most 48N + 192 bytes of memory.
 * and use space proportional to the number of items currently in the deque.
 *
 * Additionally, your iterator implementation must support each operation (including construction) in constant worst-case time.
 */
public class Deque<Item> implements Iterable<Item> {
    private int N;             // size of the stack
    private Node first;
    private Node last;

    // helper linked list class
    private class Node {
        private Item item;
        private Node prev;
        private Node next;
    }

    // construct an empty deque
    public Deque()  {
         N = 0;
         first = null;
         last = null;
    }

    // is the deque empty?
    public boolean isEmpty()  {
         return N == 0;
    }

    // return the number of items on the deque
    public int size()  {
         return N;
    }

    //Throw a java.lang.NullPointerException if the client attempts to add a null item
    public void addFirst(Item item)  {        // add the item to the front
        if(item == null) {
            throw new NullPointerException("add a null item");
        }
        Node oldfirst = first;
        first = new Node();
        first.item = item;
        first.next = oldfirst;
        first.prev = null;
        if(isEmpty()) {
           last = first;
        } else {
           oldfirst.prev = first;
        }
        N++;
    }

    //Throw a java.lang.NullPointerException if the client attempts to add a null item
    public void addLast(Item item)   {        // add the item to the end
        if(item == null) {
            throw new NullPointerException("add a null item");
        }
        Node oldlast = last;
        last = new Node();
        last.item = item;
        last.next = null;
        last.prev = oldlast;
        if(isEmpty()) {
            first = last;
        }else {
            oldlast.next = last;
        }
        N++;
    }

    //remove and return the item from the front
    // throw a java.util.NoSuchElementException if the client attempts to remove an item from an empty deque
    public Item removeFirst()   {
        if (isEmpty()) {
            throw new NoSuchElementException("Deque underflow");
        }
        Item item = first.item; // save item to return
        Node oldfirst = first;
        first = first.next;  // delete first node
        oldfirst = null;
        if(first == null) {
            last = null;
        } else {
           first.prev = null;
        }
        N--;
        return item;
    }

    // remove and return the item from the end
    // throw a java.util.NoSuchElementException if the client attempts to remove an item from an empty deque
    public Item removeLast()   {
        if (isEmpty()) {
            throw new NoSuchElementException("Deque underflow");
        }
        Item item = last.item; //save item to return
        Node oldlast = last;
        last = last.prev;
        oldlast.prev = null;

        if(last != null) {
            last.next = null;
        }else {
            first = null;
        }
        oldlast = null;
        N--;
        return item;
    }

    // return an iterator over items in order from front to end
    public Iterator<Item> iterator()   {
        return new ListIterator();
    }

    private class ListIterator implements Iterator<Item> {
        private Node current = first;

        public boolean hasNext()  {
            return current != null;
        }
        public void remove()  {
            throw new UnsupportedOperationException();
        }

        public Item next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            Item item = current.item;
            current = current.next;
            return item;
        }
    }

    public static void main(String[] args)  { // unit testing
          //testSimpleAddRemove();
          testAddRemoveallItems();
    }
    private static void testSimpleAddRemove() {
        Deque<Integer> d = new Deque<Integer>();
        d.addFirst(10);
        d.addFirst(20);
        d.addFirst(30);
        d.addLast(100);
        d.addLast(101);
        d.addLast(102);

        assert d.size() == 6;
        System.out.println(d.size());

        Iterator i = d.iterator();
        while (i.hasNext()) {
            System.out.print(i.next() + " ");
        }
        System.out.println("");

        System.out.println("d.removeFirst() is " + d.removeFirst());
        System.out.println("d.removeLast() is " + d.removeLast());
        System.out.println(d.size());

         i = d.iterator();
        while (i.hasNext()) {
            System.out.print(i.next() + " ");
        }
        System.out.println("");
    }

     private static void testAddRemoveallItems() {
        Deque<Integer> d = new Deque<Integer>();

        d.addFirst(10);
        //d.addLast(20);

         Iterator i = d.iterator();
        while (i.hasNext()) {
            System.out.print(i.next() + " ");
        }
        System.out.println("");
        System.out.println("d.size is " + d.size());
      //System.out.println("d.removeFirst() is " + d.removeFirst());
        System.out.println("d.removeLast() is " + d.removeLast());
        System.out.println("d.size is " + d.size());
    }
}