8.2. Linked Queues¶
8.2.1. Linked Queues¶
The linked queue implementation is a straightforward adaptation of the linked list. Here is the linked queue class declaration.
// Linked queue implementation
class LQueue implements Queue {
private Link front; // Pointer to front queue node
private Link rear; // Pointer to rear queuenode
private int size; // Number of elements in queue
// Constructors
LQueue() { init(); }
LQueue(int size) { init(); } // Ignore size
// Initialize queue
private void init() {
front = rear = new Link(null);
size = 0;
}
// Put element on rear
boolean enqueue(Object it) {
rear.setNext(new Link(it, null));
rear = rear.next();
size++;
return true;
}
// Remove and return element from front
Object dequeue() {
if (size == 0) return null;
Object it = front.next().element(); // Store the value
front.setNext(front.next().next()); // Advance front
if (front.next() == null) rear = front; // Last Object
size--;
return it; // Return Object
}
// Return front element
Object frontValue() {
if (size == 0) return null;
return front.next().element();
}
// Return queue size
int length() { return size; }
}
8.2.3. Comparison of Array-Based and Linked Queues¶
All member functions for both the array-based and linked queue implementations require constant time. The space comparison issues are the same as for the equivalent stack implementations. Unlike the array-based stack implementation, there is no convenient way to store two queues in the same array, unless items are always transferred directly from one queue to the other.