算法Sedgewick第四版-第1章基础-011一用链表实现bag、queue、stack

1.

 package algorithms.ADT;

 /******************************************************************************
  *  Compilation:  javac Bag.java
  *  Execution:    java Bag < input.txt
  *  Dependencies: StdIn.java StdOut.java
  *
  *  A generic bag or multiset, implemented using a singly-linked list.
  *
  *  % more tobe.txt
  *  to be or not to - be - - that - - - is
  *
  *  % java Bag < tobe.txt
  *  size of bag = 14
  *  is
  *  -
  *  -
  *  -
  *  that
  *  -
  *  -
  *  be
  *  -
  *  to
  *  not
  *  or
  *  be
  *  to
  *
  ******************************************************************************/

 import java.util.Iterator;
 import java.util.NoSuchElementException;

 import algorithms.util.StdIn;
 import algorithms.util.StdOut;

 /**
  *  The <tt>Bag</tt> class represents a bag (or multiset) of
  *  generic items. It supports insertion and iterating over the
  *  items in arbitrary order.
  *  <p>
  *  This implementation uses a singly-linked list with a static nested class Node.
  *  See {@link LinkedBag} for the version from the
  *  textbook that uses a non-static nested class.
  *  The <em>add</em>, <em>isEmpty</em>, and <em>size</em> operations
  *  take constant time. Iteration takes time proportional to the number of items.
  *  <p>
  *  For additional documentation, see <a href="http://algs4.cs.princeton.edu/13stacks">Section 1.3</a> of
  *  <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne.
  *
  *  @author Robert Sedgewick
  *  @author Kevin Wayne
  *
  *  @param <Item> the generic type of an item in this bag
  */
 public class Bag<Item> implements Iterable<Item> {
     private Node<Item> first;    // beginning of bag
     private int N;               // number of elements in bag

     // helper linked list class
     private static class Node<Item> {
         private Item item;
         private Node<Item> next;
     }

     /**
      * Initializes an empty bag.
      */
     public Bag() {
         first = null;
         N = 0;
     }

     /**
      * Returns true if this bag is empty.
      *
      * @return <tt>true</tt> if this bag is empty;
      *         <tt>false</tt> otherwise
      */
     public boolean isEmpty() {
         return first == null;
     }

     /**
      * Returns the number of items in this bag.
      *
      * @return the number of items in this bag
      */
     public int size() {
         return N;
     }

     /**
      * Adds the item to this bag.
      *
      * @param  item the item to add to this bag
      */
     public void add(Item item) {
         Node<Item> oldfirst = first;
         first = new Node<Item>();
         first.item = item;
         first.next = oldfirst;
         N++;
     }

     /**
      * Returns an iterator that iterates over the items in this bag in arbitrary order.
      *
      * @return an iterator that iterates over the items in this bag in arbitrary order
      */
     public Iterator<Item> iterator()  {
         return new ListIterator<Item>(first);
     }

     // an iterator, doesn't implement remove() since it's optional
     private class ListIterator<Item> implements Iterator<Item> {
         private Node<Item> current;

         public ListIterator(Node<Item> first) {
             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;
         }
     }

     /**
      * Unit tests the <tt>Bag</tt> data type.
      */
     public static void main(String[] args) {
         Bag<String> bag = new Bag<String>();
         while (!StdIn.isEmpty()) {
             String item = StdIn.readString();
             bag.add(item);
         }

         StdOut.println("size of bag = " + bag.size());
         for (String s : bag) {
             StdOut.println(s);
         }
     }

 }

2.

 package algorithms.ADT;

 /******************************************************************************
  *  Compilation:  javac Queue.java
  *  Execution:    java Queue < input.txt
  *  Dependencies: StdIn.java StdOut.java
  *  Data files:   http://algs4.cs.princeton.edu/13stacks/tobe.txt
  *
  *  A generic queue, implemented using a linked list.
  *
  *  % java Queue < tobe.txt
  *  to be or not to be (2 left on queue)
  *
  ******************************************************************************/

 import java.util.Iterator;
 import java.util.NoSuchElementException;

 import algorithms.util.StdIn;
 import algorithms.util.StdOut;

 /**
  *  The <tt>Queue</tt> class represents a first-in-first-out (FIFO)
  *  queue of generic items.
  *  It supports the usual <em>enqueue</em> and <em>dequeue</em>
  *  operations, along with methods for peeking at the first item,
  *  testing if the queue is empty, and iterating through
  *  the items in FIFO order.
  *  <p>
  *  This implementation uses a singly-linked list with a static nested class for
  *  linked-list nodes. See {@link LinkedQueue} for the version from the
  *  textbook that uses a non-static nested class.
  *  The <em>enqueue</em>, <em>dequeue</em>, <em>peek</em>, <em>size</em>, and <em>is-empty</em>
  *  operations all take constant time in the worst case.
  *  <p>
  *  For additional documentation, see <a href="http://algs4.cs.princeton.edu/13stacks">Section 1.3</a> of
  *  <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne.
  *
  *  @author Robert Sedgewick
  *  @author Kevin Wayne
  *
  *  @param <Item> the generic type of an item in this queue
  */
 public class Queue<Item> implements Iterable<Item> {
     private Node<Item> first;    // beginning of queue
     private Node<Item> last;     // end of queue
     private int N;               // number of elements on queue

     // helper linked list class
     private static class Node<Item> {
         private Item item;
         private Node<Item> next;
     }

     /**
      * Initializes an empty queue.
      */
     public Queue() {
         first = null;
         last  = null;
         N = 0;
     }

     /**
      * Returns true if this queue is empty.
      *
      * @return <tt>true</tt> if this queue is empty; <tt>false</tt> otherwise
      */
     public boolean isEmpty() {
         return first == null;
     }

     /**
      * Returns the number of items in this queue.
      *
      * @return the number of items in this queue
      */
     public int size() {
         return N;
     }

     /**
      * Returns the item least recently added to this queue.
      *
      * @return the item least recently added to this queue
      * @throws NoSuchElementException if this queue is empty
      */
     public Item peek() {
         if (isEmpty()) throw new NoSuchElementException("Queue underflow");
         return first.item;
     }

     /**
      * Adds the item to this queue.
      *
      * @param  item the item to add
      */
     public void enqueue(Item item) {
         Node<Item> oldlast = last;
         last = new Node<Item>();
         last.item = item;
         last.next = null;
         if (isEmpty()) first = last;
         else           oldlast.next = last;
         N++;
     }

     /**
      * Removes and returns the item on this queue that was least recently added.
      *
      * @return the item on this queue that was least recently added
      * @throws NoSuchElementException if this queue is empty
      */
     public Item dequeue() {
         if (isEmpty()) throw new NoSuchElementException("Queue underflow");
         Item item = first.item;
         first = first.next;
         N--;
         if (isEmpty()) last = null;   // to avoid loitering
         return item;
     }

     /**
      * Returns a string representation of this queue.
      *
      * @return the sequence of items in FIFO order, separated by spaces
      */
     public String toString() {
         StringBuilder s = new StringBuilder();
         for (Item item : this)
             s.append(item + " ");
         return s.toString();
     } 

     /**
      * Returns an iterator that iterates over the items in this queue in FIFO order.
      *
      * @return an iterator that iterates over the items in this queue in FIFO order
      */
     public Iterator<Item> iterator()  {
         return new ListIterator<Item>(first);
     }

     // an iterator, doesn't implement remove() since it's optional
     private class ListIterator<Item> implements Iterator<Item> {
         private Node<Item> current;

         public ListIterator(Node<Item> first) {
             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;
         }
     }

     /**
      * Unit tests the <tt>Queue</tt> data type.
      */
     public static void main(String[] args) {
         Queue<String> q = new Queue<String>();
         while (!StdIn.isEmpty()) {
             String item = StdIn.readString();
             if (!item.equals("-")) q.enqueue(item);
             else if (!q.isEmpty()) StdOut.print(q.dequeue() + " ");
         }
         StdOut.println("(" + q.size() + " left on queue)");
     }
 }

3.

 package algorithms.ADT;

 /******************************************************************************
  *  Compilation:  javac Stack.java
  *  Execution:    java Stack < input.txt
  *  Dependencies: StdIn.java StdOut.java
  *
  *  A generic stack, implemented using a singly-linked list.
  *  Each stack element is of type Item.
  *
  *  This version uses a static nested class Node (to save 8 bytes per
  *  Node), whereas the version in the textbook uses a non-static nested
  *  class (for simplicity).
  *
  *  % more tobe.txt
  *  to be or not to - be - - that - - - is
  *
  *  % java Stack < tobe.txt
  *  to be not that or be (2 left on stack)
  *
  ******************************************************************************/

 import java.util.Iterator;
 import java.util.NoSuchElementException;

 import algorithms.util.StdIn;
 import algorithms.util.StdOut;

 /**
  *  The <tt>Stack</tt> class represents a last-in-first-out (LIFO) stack of generic items.
  *  It supports the usual <em>push</em> and <em>pop</em> operations, along with methods
  *  for peeking at the top item, testing if the stack is empty, and iterating through
  *  the items in LIFO order.
  *  <p>
  *  This implementation uses a singly-linked list with a static nested class for
  *  linked-list nodes. See {@link LinkedStack} for the version from the
  *  textbook that uses a non-static nested class.
  *  The <em>push</em>, <em>pop</em>, <em>peek</em>, <em>size</em>, and <em>is-empty</em>
  *  operations all take constant time in the worst case.
  *  <p>
  *  For additional documentation,
  *  see <a href="http://algs4.cs.princeton.edu/13stacks">Section 1.3</a> of
  *  <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne.
  *
  *  @author Robert Sedgewick
  *  @author Kevin Wayne
  *
  *  @param <Item> the generic type of an item in this stack
  */
 public class Stack<Item> implements Iterable<Item> {
     private Node<Item> first;     // top of stack
     private int N;                // size of the stack

     // helper linked list class
     private static class Node<Item> {
         private Item item;
         private Node<Item> next;
     }

     /**
      * Initializes an empty stack.
      */
     public Stack() {
         first = null;
         N = 0;
     }

     /**
      * Returns true if this stack is empty.
      *
      * @return true if this stack is empty; false otherwise
      */
     public boolean isEmpty() {
         return first == null;
     }

     /**
      * Returns the number of items in this stack.
      *
      * @return the number of items in this stack
      */
     public int size() {
         return N;
     }

     /**
      * Adds the item to this stack.
      *
      * @param  item the item to add
      */
     public void push(Item item) {
         Node<Item> oldfirst = first;
         first = new Node<Item>();
         first.item = item;
         first.next = oldfirst;
         N++;
     }

     /**
      * Removes and returns the item most recently added to this stack.
      *
      * @return the item most recently added
      * @throws NoSuchElementException if this stack is empty
      */
     public Item pop() {
         if (isEmpty()) throw new NoSuchElementException("Stack underflow");
         Item item = first.item;        // save item to return
         first = first.next;            // delete first node
         N--;
         return item;                   // return the saved item
     }

     /**
      * Returns (but does not remove) the item most recently added to this stack.
      *
      * @return the item most recently added to this stack
      * @throws NoSuchElementException if this stack is empty
      */
     public Item peek() {
         if (isEmpty()) throw new NoSuchElementException("Stack underflow");
         return first.item;
     }

     /**
      * Returns a string representation of this stack.
      *
      * @return the sequence of items in this stack in LIFO order, separated by spaces
      */
     public String toString() {
         StringBuilder s = new StringBuilder();
         for (Item item : this)
             s.append(item + " ");
         return s.toString();
     }

     /**
      * Returns an iterator to this stack that iterates through the items in LIFO order.
      *
      * @return an iterator to this stack that iterates through the items in LIFO order
      */
     public Iterator<Item> iterator() {
         return new ListIterator<Item>(first);
     }

     // an iterator, doesn't implement remove() since it's optional
     private class ListIterator<Item> implements Iterator<Item> {
         private Node<Item> current;

         public ListIterator(Node<Item> first) {
             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;
         }
     }

     /**
      * Unit tests the <tt>Stack</tt> data type.
      */
     public static void main(String[] args) {
         Stack<String> s = new Stack<String>();
         while (!StdIn.isEmpty()) {
             String item = StdIn.readString();
             if (!item.equals("-")) s.push(item);
             else if (!s.isEmpty()) StdOut.print(s.pop() + " ");
         }
         StdOut.println("(" + s.size() + " left on stack)");
     }
 }