算法Sedgewick第四版-第1章基础-015一stack只保留last指针

  1 /*************************************************************************
  2  *
  3  *  A generic queue, implemented using a *circular* linked list.
  4  *  (Exercise 1.3.29)
  5  *
  6  *  % java Ex_1_3_29 < tobe.txt
  7  *  to be or not to be (2 left on queue)
  8  *
  9  *************************************************************************/
 10
 11 import java.util.Iterator;
 12 import java.util.NoSuchElementException;
 13
 14 public class Ex_1_3_29<Item> implements Iterable<Item> {
 15     private int N;
 16     private Node last;
 17
 18     private class Node {
 19         private Item item;
 20         private Node next;
 21     }
 22
 23    /**
 24      * Create an empty queue.
 25      */
 26     public Ex_1_3_29() {
 27         last  = null;
 28     }
 29
 30    /**
 31      * Is the queue empty?
 32      */
 33     public boolean isEmpty() {
 34         return last == null;
 35     }
 36
 37    /**
 38      * Return the number of items in the queue.
 39      */
 40     public int size() {
 41         return N;
 42     }
 43
 44    /**
 45      * Return the item least recently added to the queue.
 46      * Throw an exception if the queue is empty.
 47      */
 48     public Item peek() {
 49         if (isEmpty()) throw new RuntimeException("Queue underflow");
 50         return last.next.item;
 51     }
 52
 53    /**
 54      * Add the item to the queue.
 55      */
 56     public void enqueue(Item item) {
 57         Node x = new Node();
 58         x.item = item;
 59         if (isEmpty())
 60             x.next = x;
 61         else
 62         {
 63             x.next = last.next;
 64             last.next = x;
 65         }
 66         last = x;
 67         N++;
 68     }
 69
 70    /**
 71      * Remove and return the item on the queue least recently added.
 72      * Throw an exception if the queue is empty.
 73      */
 74     public Item dequeue() {
 75         if (isEmpty()) throw new RuntimeException("Queue underflow");
 76         Item item = last.next.item;
 77         if (last.next == last)
 78             last = null;
 79         else
 80             last.next = last.next.next;
 81         N--;
 82         return item;
 83     }
 84
 85    /**
 86      * Return string representation.
 87      */
 88     public String toString() {
 89         StringBuilder s = new StringBuilder();
 90         for (Item item : this)
 91             s.append(item + " ");
 92         return s.toString();
 93     }
 94
 95
 96    /**
 97      * Return an iterator that iterates over the items on the queue in FIFO order.
 98      */
 99     public Iterator<Item> iterator()  {
100         return new ListIterator();
101     }
102
103     private class ListIterator implements Iterator<Item> {
104         private int n = N;
105         private Node current = last;
106
107         public boolean hasNext()  { return n > 0; }
108         public void remove()      { throw new UnsupportedOperationException();  }
109
110         public Item next() {
111             if (!hasNext()) throw new NoSuchElementException();
112             Item item = current.next.item;
113             current = current.next;
114             n--;
115             return item;
116         }
117     }
118
119
120     public static void main(String[] args) {
121         Ex_1_3_29<String> q = new Ex_1_3_29<String>();
122         while (!StdIn.isEmpty()) {
123             String item = StdIn.readString();
124             if (!item.equals("-")) q.enqueue(item);
125             else if (!q.isEmpty()) StdOut.print(q.dequeue() + " ");
126         }
127         StdOut.println("(" + q.size() + " left on queue: [ " + q + "])");
128     }
129 }