129 lines
3.3 KiB
Java
129 lines
3.3 KiB
Java
package net.datastructures;
|
|
|
|
/**
|
|
* Realization of a queue by means of a singly-linked list of nodes.
|
|
* All operations are performed in constant time.
|
|
*
|
|
* @author Roberto Tamassia
|
|
*/
|
|
|
|
public class NodeQueue<E> implements Queue<E> {
|
|
|
|
protected Node<E> head, tail; // the head and tail nodes
|
|
protected int size; // Keeps track of number of elements in queue
|
|
|
|
/** Creates an empty queue. */
|
|
public NodeQueue() {
|
|
head = null;
|
|
tail = null;
|
|
size = 0;
|
|
}
|
|
|
|
public int size() { //# Return the current queue size
|
|
return size;
|
|
}
|
|
|
|
public boolean isEmpty() { //# Returns true iff queue is empty
|
|
if ( (head==null) && (tail==null) )
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
//begin#fragment enqueue
|
|
public void enqueue(E elem) {
|
|
Node<E> node = new Node<E>();
|
|
node.setElement(elem);
|
|
node.setNext(null); // node will be new tail node
|
|
if (size == 0)
|
|
head = node; // special case of a previously empty queue
|
|
else
|
|
tail.setNext(node); // add node at the tail of the list
|
|
tail = node; // update the reference to the tail node
|
|
size++;
|
|
}
|
|
//end#fragment enqueue
|
|
|
|
public E front() //# Return the first queue element
|
|
throws EmptyQueueException {
|
|
if (size == 0)
|
|
throw new EmptyQueueException("Queue is empty.");
|
|
return head.getElement();
|
|
}
|
|
|
|
//begin#fragment dequeue
|
|
public E dequeue() throws EmptyQueueException {
|
|
if (size == 0)
|
|
throw new EmptyQueueException("Queue is empty.");
|
|
E tmp = head.getElement();
|
|
head = head.getNext();
|
|
size--;
|
|
if (size == 0)
|
|
tail = null; // the queue is now empty
|
|
return tmp;
|
|
}
|
|
//end#fragment dequeue
|
|
|
|
public String toString() {
|
|
String s = "";
|
|
s += "(";
|
|
if (!isEmpty()) {
|
|
Node p = head;
|
|
do {
|
|
s += p.getElement() ;
|
|
if (p != tail)
|
|
s += ", ";
|
|
p = p.getNext();
|
|
} while (p != null);
|
|
}
|
|
s += ")";
|
|
return s;
|
|
}
|
|
|
|
/**
|
|
* Prints information about an operation and the queue.
|
|
* @param op operation performed
|
|
* @param element element returned by the operation
|
|
* @return information about the operation performed, the element
|
|
* returned by the operation and the content of the stack after
|
|
* the operation.
|
|
*/
|
|
public static void status(Queue Q, String op, Object element) {
|
|
System.out.println("---------------------------------");
|
|
System.out.println(op);
|
|
System.out.println("Returned: " + element);
|
|
String emptyStatus;
|
|
if (Q.isEmpty())
|
|
emptyStatus = "empty";
|
|
else
|
|
emptyStatus = "not empty";
|
|
System.out.println("size = " + Q.size() + ", " + emptyStatus);
|
|
System.out.println("Queue: " + Q);
|
|
}
|
|
|
|
/**
|
|
* Test program that performs a series of operations on on a queue and
|
|
* prints the operation performed, the returned element and the
|
|
* content of the stack after each operation.
|
|
*/
|
|
public static void main(String[] args) {
|
|
Object o;
|
|
Queue<Integer> A = new NodeQueue<Integer>();
|
|
status (A, "New empty queue", null);
|
|
A.enqueue(5);
|
|
status (A, "enqueue(5)", null);
|
|
A.enqueue(3);
|
|
status (A, "enqueue(3)", null);
|
|
A.enqueue(7);
|
|
status (A, "enqueue(7)", null);
|
|
o = A.dequeue();
|
|
status (A, "dequeue()", o);
|
|
A.enqueue(9);
|
|
status (A, "enqueue(9)", null);
|
|
o = A.dequeue();
|
|
status (A, "dequeue()", o);
|
|
o = o = A.front();
|
|
status (A, "front()", o);
|
|
}
|
|
|
|
}
|