140 lines
3.4 KiB
Java
140 lines
3.4 KiB
Java
|
|
|
|
/*************************************************************************
|
|
* Compilation: javac LinkedBag.java
|
|
* Execution: java LinkedBag < input.txt
|
|
*
|
|
* 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 edu.princeton.cs.introcs.StdIn;
|
|
import edu.princeton.cs.introcs.StdOut;
|
|
|
|
/**
|
|
* The LinkedBag class represents a bag (or multiset) of
|
|
* generic items. It supports insertion and iterating over the
|
|
* items in arbitrary order.
|
|
*
|
|
* This implementation uses a singly-linked list with a non-static nested class Node.
|
|
* See {@link Bag} for a version that uses a static nested class.
|
|
* The add , isEmpty , and size operations
|
|
* take constant time. Iteration takes time proportional to the number of items.
|
|
*
|
|
* For additional documentation, see <a href="http://algs4.cs.princeton.edu/13stacks">Section 1.3</a> of
|
|
* Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.
|
|
*
|
|
* @author Robert Sedgewick
|
|
* @author Kevin Wayne
|
|
*/
|
|
public class LinkedBag<Item> implements Iterable<Item> {
|
|
private int N; // number of elements in bag
|
|
private Node first; // beginning of bag
|
|
|
|
// helper linked list class
|
|
private class Node {
|
|
private Item item;
|
|
private Node next;
|
|
}
|
|
|
|
/**
|
|
* Initializes an empty bag.
|
|
*/
|
|
public LinkedBag() {
|
|
first = null;
|
|
N = 0;
|
|
}
|
|
|
|
/**
|
|
* Is this bag empty?
|
|
* @return true if this bag is empty; false 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 oldfirst = first;
|
|
first = new Node();
|
|
first.item = item;
|
|
first.next = oldfirst;
|
|
N++;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns an iterator that iterates over the items in the bag.
|
|
*/
|
|
public Iterator<Item> iterator() {
|
|
return new ListIterator();
|
|
}
|
|
|
|
// an iterator, doesn't implement remove() since it's optional
|
|
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;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unit tests the LinkedBag data type.
|
|
*/
|
|
public static void main(String[] args) {
|
|
LinkedBag<String> bag = new LinkedBag<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);
|
|
}
|
|
}
|
|
|
|
|
|
}
|