| Interface | Description |
|---|---|
| AdaptablePriorityQueue<K,V> |
Interface for the adaptable priority queue ADT.
|
| BinaryTree<E> |
An interface for a binary tree, in which each node has at most two children.
|
| CircularQueue<E> |
This provides one additional method not part of the general Queue interface.
|
| Deque<E> |
Interface for a double-ended queue: a collection of elements that can be inserted
and removed at both ends; this interface is a simplified version of java.util.Deque.
|
| Edge<E> |
An edge of a graph.
|
| Entry<K,V> |
Interface for a key-value pair.
|
| Graph<V,E> |
An interface for a graph structure.
|
| List<E> |
A simplified version of the java.util.List interface.
|
| Map<K,V> |
An interface for an associative map which binds a key uniquely to a value.
|
| Position<E> |
An interface for a position which is an abstraction for the
location at which a single element is stored in a positional
container.
|
| PositionalList<E> |
An interface for positional lists.
|
| PriorityQueue<K,V> |
Interface for the priority queue ADT.
|
| Queue<E> |
Interface for a queue: a collection of elements that are inserted
and removed according to the first-in first-out principle.
|
| SortedMap<K,V> |
A map with additional support for keys from a total ordering.
|
| Stack<E> |
A collection of objects that are inserted and removed according to the last-in
first-out principle.
|
| Tree<E> |
An interface for a tree where nodes can have an arbitrary number of children.
|
| Vertex<V> |
A vertex of a graph.
|
| Class | Description |
|---|---|
| AbstractBinaryTree<E> |
An abstract base class providing some functionality of the BinaryTree interface.
|
| AbstractHashMap<K,V> |
An abstract base class supporting Map implementations that use hash
tables with MAD compression.
|
| AbstractMap<K,V> |
An abstract base class to ease the implementation of the Map interface.
|
| AbstractMap.MapEntry<K,V> |
A concrete implementation of the Entry interface to be used
within a Map implementation.
|
| AbstractPriorityQueue<K,V> |
An abstract base class to ease the implementation of the PriorityQueue interface.
|
| AbstractPriorityQueue.PQEntry<K,V> |
A concrete implementation of the Entry interface to be used within
a PriorityQueue implementation.
|
| AbstractSortedMap<K,V> |
An abstract base class to ease the implementation of the SortedMap interface.
|
| AbstractTree<E> |
An abstract base class providing some functionality of the Tree interface.
|
| AdjacencyMapGraph<V,E> |
An implementation for a graph structure using an adjacency map for each vertex.
|
| ArrayList<E> |
Realization of a list by means of a dynamic array.
|
| ArrayQueue<E> |
Implementation of the queue ADT using a fixed-length array.
|
| ArrayStack<E> |
Implementation of the stack ADT using a fixed-length array.
|
| AVLTreeMap<K,V> |
An implementation of a sorted map using an AVL tree.
|
| ChainHashMap<K,V> | |
| ChainHashMapOld<K,V> | |
| CircularlyLinkedList<E> |
An implementation of a circularly linked list.
|
| DefaultComparator<E> |
Comparator based on the compareTo method of a Comparable element type.
|
| DoublyLinkedList<E> |
A basic doubly linked list implementation.
|
| GraphAlgorithms |
A collection of graph algorithms.
|
| GraphExamples |
This class provides a utility to build a graph from a list of edges.
|
| HeapAdaptablePriorityQueue<K,V> |
An implementation of an adaptable priority queue using an array-based heap.
|
| HeapAdaptablePriorityQueue.AdaptablePQEntry<K,V> |
Extension of the PQEntry to include location information.
|
| HeapPriorityQueue<K,V> |
An implementation of a priority queue using an array-based heap.
|
| LinkedBinaryTree<E> |
Concrete implementation of a binary tree using a node-based, linked structure.
|
| LinkedBinaryTree.Node<E> |
Nested static class for a binary tree node.
|
| LinkedCircularQueue<E> |
Realization of a circular FIFO queue as an adaptation of a CircularlyLinkedList.
|
| LinkedDeque<E> |
Realization of a double-ended queue (deque) as an adaptation of a
DoublyLinkedList.
|
| LinkedPositionalList<E> |
Implementation of a positional list stored as a doubly linked list.
|
| LinkedQueue<E> |
Realization of a FIFO queue as an adaptation of a SinglyLinkedList.
|
| LinkedStack<E> |
Realization of a stack as an adaptation of a SinglyLinkedList.
|
| Partition<E> |
A Union-Find structure for maintaining disjoint sets.
|
| ProbeHashMap<K,V> | |
| RBTreeMap<K,V> |
An implementation of a sorted map using a red-black tree.
|
| SinglyLinkedList<E> |
A basic singly linked list implementation.
|
| SortedPriorityQueue<K,V> |
An implementation of a priority queue with a sorted list.
|
| SortedTableMap<K,V> |
An implementation of a map using a sorted table.
|
| SplayTreeMap<K,V> |
An implementation of a sorted map using a splay tree.
|
| TreeMap<K,V> |
An implementation of a sorted map using a binary search tree.
|
| TreeMap.BalanceableBinaryTree<K,V> |
A specialized version of the LinkedBinaryTree class with
additional mutators to support binary search tree operations, and
a specialized node class that includes an auxiliary instance
variable for balancing data.
|
| TreeMap.BalanceableBinaryTree.BSTNode<E> | |
| UnsortedPriorityQueue<K,V> |
An implementation of a priority queue with an unsorted list.
|
| UnsortedTableMap<K,V> |
An implementation of a map using an unsorted table.
|