You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
146 lines
3.6 KiB
Java
146 lines
3.6 KiB
Java
|
|
|
|
/*************************************************************************
|
|
* Compilation: javac Bag.java
|
|
* Execution: java Bag < 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 Bag 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 static nested class Node.
|
|
* See {@link LinkedBag} for the version from the
|
|
* textbook that uses a non-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 Bag<Item> implements Iterable<Item> {
|
|
private int N; // number of elements in bag
|
|
private Node<Item> first; // beginning of 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;
|
|
}
|
|
|
|
/**
|
|
* 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<Item> oldfirst = first;
|
|
first = new Node<Item>();
|
|
first.item = item;
|
|
first.next = oldfirst;
|
|
N++;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns an iterator that iterates over the items in the bag in arbitrary order.
|
|
* @return an iterator that iterates over the items in the 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 Bag 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);
|
|
}
|
|
}
|
|
|
|
|
|
}
|