|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Collection | |
---|---|
goldman.collection | The Collection interface contains the operations that must be supported by all data structures that maintain a collection of elements. |
goldman.collection.ordered | An ordered collection is an untagged algorithmically positioned collection of comparable elements that may contain duplicates. |
goldman.collection.ordered.digitized | A digitized ordered collection is an untagged algorithmically positioned collection whose elements can each be viewed as a sequence of digits (e.g., bit string, character string). |
goldman.collection.positional | A positional collection is a manually positioned collection in which elements are accessed via their position in a line (with 0 being the position of the first element in the line) or via their location relative to other elements in the line. |
goldman.collection.priority | A priority queue is an untagged algorithmically positioned collection of comparable elements in which there can be equivalent elements. |
goldman.collection.set | A set is an untagged algorithmically positioned collection of elements in which no two elements are equivalent. |
goldman.collection.spatial | A spatial collection is an untagged algorithmically positioned collection that organizes its elements by their location in a multidimensional space. |
goldman.collection.tagged | A tagged collection is a collection that provides the necessary support for associating these tags with the corresponding elements. |
goldman.collection.tagged.bucket | A tagged bucket collection holds tagged elements in which each tag is associated with a bucket holding all elements with that tag. |
goldman.collection.tagged.ordered.digitized | A tagged digitized ordered collection is the tagged variation of a digitized ordered collection. |
goldman.collection.tagged.priority | A tagged priority queue is the tagged version of a priority queue. |
goldman.collection.tagged.spatial | A tagged spatial collection is the tagged variation of a spatial collection. |
Uses of Collection in goldman.collection |
---|
Subinterfaces of Collection in goldman.collection | |
---|---|
interface |
Tracked<E>
The Tracked interface adds a single method to
the Collection interface that allows the user to obtain a tracker
when an element is inserted. |
Classes in goldman.collection that implement Collection | |
---|---|
class |
AbstractCollection<E>
The AbstractCollection class implements methods that can be shared by all data structures that implement a collection. |
Methods in goldman.collection with parameters of type Collection | ||
---|---|---|
void |
Collection.addAll(Collection<? extends E> c)
Adds all elements in c
to this collection. |
|
void |
AbstractCollection.addAll(Collection<? extends E> c)
Adds all elements in c to the collection. |
|
static
|
AbstractCollection.getElementAtRank(Collection<T> coll,
int rank)
This is a non-mutating method. |
|
static
|
AbstractCollection.getElementAtRank(Collection<T> coll,
int rank,
Comparator<? super T> comp)
This is a non-mutating method. |
|
void |
Collection.retainAll(Collection<E> c)
Removes from this collection all elements for which there is no equivalent element in c . |
|
void |
AbstractCollection.retainAll(Collection<E> c)
Updates the current collection to contain only elements that are also in c |
Constructors in goldman.collection with parameters of type Collection | |
---|---|
DefaultBucketizer(Collection<T> coll,
Quantizer<? super T> quantizer)
|
Uses of Collection in goldman.collection.ordered |
---|
Subinterfaces of Collection in goldman.collection.ordered | |
---|---|
interface |
OrderedCollection<E>
An ordered collection is an untagged algorithmically positioned collection of comparable elements that may contain duplicates. |
Classes in goldman.collection.ordered that implement Collection | |
---|---|
class |
AbstractSearchTree<E>
The AbstractSearchTree class is an abstract class that includes the methods that are shared by all search trees. |
class |
BalancedBinarySearchTree<E>
A balanced binary search tree uses rotations to maintain balance when one path to a leaf becomes "to much longer" than another. |
class |
BinarySearchTree<E>
This class implements a standard binary search tree. |
class |
BPlusTree<E>
The B+-tree is variation of a B-tree in which the internal nodes are used only for navigation. |
class |
BTree<E>
A B-tree is a balanced binary search tree in which each node can hold between t-1 and 2t-1 elements, where integer t > 1 is provided as a parameter to the constructor. |
class |
RedBlackTree<E>
The red-black tree is a balanced binary search tree in which a single bit (a color of red or black) associated with each tree node is used to ensure that the number of comparisons made when searching for any element is at most 2 log2 n. |
class |
SkipList<E>
The skip list is a sorted list with additional structure that supports finding an element in expected logarithmic time. |
class |
SortedArray<E>
The sorted array provides very efficient use of space and the fastest search time independent of the access pattern. |
class |
SplayTree<E>
A splay tree is a form of a balanced binary search tree in which the nodes store no explicit information to enforce a balancing condition. |
class |
TopDownBTree<E>
The top down B-tree implements a variation of a B-tree that uses top-down (versus bottom-up) insertion and deletion. |
Methods in goldman.collection.ordered with parameters of type Collection | |
---|---|
void |
SortedArray.addAll(Collection<? extends E> c)
Adds all elements in c to the collection. |
void |
SkipList.addAll(Collection<? extends E> c)
Iterates through c and adds each element in
c to the collection |
void |
SortedArray.retainAll(Collection<E> c)
Updates the current collection to contain only elements that are also in c |
void |
SkipList.retainAll(Collection<E> c)
Updates the current collection to contain only elements that are also in c . |
Uses of Collection in goldman.collection.ordered.digitized |
---|
Subinterfaces of Collection in goldman.collection.ordered.digitized | |
---|---|
interface |
DigitizedOrderedCollection<E>
A digitized ordered collection is an untagged algorithmically positioned collection whose elements can each be viewed as a sequence of digits (e.g., bit string, character string). |
Classes in goldman.collection.ordered.digitized that implement Collection | |
---|---|
class |
CompactTrie<E>
The compact trie data structure modifies the trie by replacing any leaf that has no siblings by its parent. |
class |
CompressedTrie<E>
The compressed trie performs additional compression on a compact trie. |
class |
PatriciaTrie<E>
The Patricia trie is a variation of a compressed trie that can be used when the digitizer has base 2 and the collection is naturally prefix-free (without adding an end of string character). |
class |
TernarySearchTrie<E>
The ternary search trie (often referred to as a TST) is a hybrid between a trie and a binary search tree that combines the time efficiency of a trie with the space efficiency of a binary search tree. |
class |
Trie<E>
The trie data structure is the simplest DigitizedOrderedCollection
implementation. |
Methods in goldman.collection.ordered.digitized with parameters of type Collection | |
---|---|
void |
Trie.completions(E prefix,
Collection<? super E> c)
|
void |
DigitizedOrderedCollection.completions(E prefix,
Collection<? super E> c)
Appends all elements in this collection that have the given prefix to the given collection c. |
void |
Trie.longestCommonPrefix(E prefix,
Collection<? super E> c)
|
void |
DigitizedOrderedCollection.longestCommonPrefix(E element,
Collection<? super E> c)
Appends to the provided collection c all elements in this collection that have a longest common prefix with element . |
Uses of Collection in goldman.collection.positional |
---|
Subinterfaces of Collection in goldman.collection.positional | |
---|---|
interface |
PositionalCollection<E>
Often an application needs to maintain a collection of elements that are accessed via their position in a line (with 0 being the position of the first element in the line) or via their location relative to other elements in the line. |
Classes in goldman.collection.positional that implement Collection | |
---|---|
class |
AbstractPositionalCollection<E>
The AbstractPositionalCollection provides a basis for defining concrete positional collections by defining a useful set of methods that can be implemented for any positional collection in terms of the public methods from the PositionalCollection interface. |
class |
Array<E>
The simplest of the positional collections, Array provides space for a fixed number of elements, which are stored in an underlying Java primitive array. |
class |
CircularArray<E>
This array-based data structure allows element 0 of the positional collection to be in any slot of the underlying array, with the range of underlying indices wrapping around as needed. |
class |
DoublyLinkedList<E>
The doubly linked list is the only positional collection data structure that provides amortized constant time methods for all of the PositionalCollectionLocator methods except getCurrentPosition . |
class |
DynamicArray<E>
This array-based data structure provides space for a fixed number of elements, which are stored in an underlying Java primitive array. |
class |
DynamicCircularArray<E>
This array-based data structure allows element 0 of the positional collection to be in any slot of the underlying array, with the range of underlying indices wrapping around as needed, and also performs automatic resizing. |
class |
SinglyLinkedList<E>
The simplest of the list-based positional collections, SinglyLinkedList maintains a linked list where each list node only references the next element in the list. |
class |
TrackedArray<E>
This array-based data structure can wrap any of the other array-based data structures to create a tracked implementation of the wrapped data structure. |
Uses of Collection in goldman.collection.priority |
---|
Subinterfaces of Collection in goldman.collection.priority | |
---|---|
interface |
PriorityQueue<E>
A priority queue is an untagged algorithmically positioned collection of comparable elements in which there can be equivalent elements. |
Classes in goldman.collection.priority that implement Collection | |
---|---|
class |
BinaryHeap<E>
The binary heap is a very simple data structure that has worst-case logarithmic cost for add , extractMax , and update (through
a locator). |
class |
FibonacciHeap<E>
The Fibonacci heap is a more complex self-organizing data structure. |
class |
LeftistHeap<E>
The leftist heap is a fairly simple implementation that supports merge in logarithmic time. |
class |
PairingHeap<E>
The pairing heap is a simple self-organizing data structure in which the amortized cost for add , merge , and
remove through a tracker are all logarithmic. |
Methods in goldman.collection.priority with parameters of type Collection | |
---|---|
void |
BinaryHeap.addAll(Collection<? extends E> c)
|
void |
BinaryHeap.retainAll(Collection<E> c)
Updates the current collection to contain only elements that are also in c |
Uses of Collection in goldman.collection.set |
---|
Subinterfaces of Collection in goldman.collection.set | |
---|---|
interface |
Set<E>
A set is an untagged algorithmically positioned collection of elements in which no two elements are equivalent. |
Classes in goldman.collection.set that implement Collection | |
---|---|
class |
DirectAddressing<E>
This data structure provides excellent performance, but O(|U|) space is required. |
class |
OpenAddressing<E>
This data structure should also be considered when only a small fraction of the elements in the universe will be stored in the collection. |
class |
SeparateChaining<E>
This data structure should be considered when only a small fraction of the elements in U will be stored in the collection. |
Uses of Collection in goldman.collection.spatial |
---|
Subinterfaces of Collection in goldman.collection.spatial | |
---|---|
interface |
SpatialCollection<E>
A spatial collection organizes its elements by location in a multidimensional space. |
Classes in goldman.collection.spatial that implement Collection | |
---|---|
class |
KDTree<E>
The k-d tree cycles among the k dimensions, dividing each region by a halfspace with respect to the dimensions associated with that level. |
class |
QuadTree<E>
A quad tree divides the subdomain into four regions at each internal node. |
Methods in goldman.collection.spatial that return Collection | |
---|---|
Collection<E> |
SpatialCollection.withinBounds(E minCorner,
E maxCorner)
Returns a collection of the elements that fall within (or on) the boundary of the multidimensional box defined by the two given corners, minCorner and maxCorner . |
Collection<E> |
QuadTree.withinBounds(E cornerA,
E cornerB)
|
Collection<E> |
KDTree.withinBounds(E minCorner,
E maxCorner)
|
Methods in goldman.collection.spatial with parameters of type Collection | |
---|---|
void |
QuadTree.withinBounds(E cornerA,
E cornerB,
Collection<? super E> elements)
|
Uses of Collection in goldman.collection.tagged |
---|
Fields in goldman.collection.tagged declared as Collection | |
---|---|
protected Collection<TaggedElement<T,E>> |
TaggedCollectionWrapper.pairs
|
Methods in goldman.collection.tagged that return Collection | |
---|---|
Collection<E> |
TaggedCollectionWrapper.values()
This implementation creates a positional collection (specifically, an array), and the elements are inserted in the iteration order |
Collection<E> |
TaggedCollection.values()
Returns a collection of all the elements held in this tagged collection. |
Constructors in goldman.collection.tagged with parameters of type Collection | |
---|---|
TaggedCollectionWrapper(Collection<TaggedElement<T,E>> pairs)
|
Uses of Collection in goldman.collection.tagged.bucket |
---|
Fields in goldman.collection.tagged.bucket with type parameters of type Collection | |
---|---|
protected TaggedCollection<T,Collection<E>> |
TaggedBucketCollectionWrapper.tc
|
Methods in goldman.collection.tagged.bucket that return Collection | |
---|---|
Collection<E> |
BucketFactory.createBucket()
|
Collection<E> |
TaggedBucketCollectionWrapper.get(T tag)
|
Collection<E> |
TaggedBucketCollection.get(T tag)
Returns a collection of all elements with the given tag. |
Collection<E> |
TaggedBucketCollectionWrapper.removeBucket(T tag)
Removes all elements from this tagged bucket collection that are associated with the given tag. |
Collection<E> |
TaggedBucketCollection.removeBucket(T tag)
Removes and returns the bucket associated with the given tag. |
Methods in goldman.collection.tagged.bucket that return types with arguments of type Collection | |
---|---|
TaggedCollection<T,Collection<E>> |
TaggedBucketCollectionWrapper.getTaggedCollection()
|
Iterator<TaggedElement<T,Collection<E>>> |
TaggedBucketCollectionWrapper.iterator()
Creates a new iterator that is at FORE. |
Iterator<TaggedElement<T,Collection<E>>> |
TaggedBucketCollection.iterator()
Returns an iterator initialized at FORE that may be used to iterate over the tags and their associated buckets. |
Method parameters in goldman.collection.tagged.bucket with type arguments of type Collection | |
---|---|
void |
TaggedBucketCollectionWrapper.accept(Visitor<TaggedElement<T,Collection<E>>> v)
Traverses the entire collection on behalf of a visitor. |
void |
TaggedBucketCollection.accept(Visitor<TaggedElement<T,Collection<E>>> v)
Traverses each element of this collection, in the iteration order, on behalf of the visitor. |
Constructor parameters in goldman.collection.tagged.bucket with type arguments of type Collection | |
---|---|
TaggedBucketCollectionWrapper(TaggedCollection<T,Collection<E>> tc,
BucketFactory<E> factory)
|
|
TaggedBucketCollectionWrapper(TaggedCollection<T,Collection<E>> tc,
Class bucketType)
|
Uses of Collection in goldman.collection.tagged.ordered.digitized |
---|
Methods in goldman.collection.tagged.ordered.digitized with parameters of type Collection | |
---|---|
void |
TaggedDigitizedOrderedCollectionWrapper.completions(T prefix,
Collection<? super TaggedElement<T,E>> tc)
|
void |
TaggedDigitizedOrderedCollection.completions(T prefix,
Collection<? super TaggedElement<T,E>> tc)
Adds to the provided tagged collection, tc , all tagged elements for which the tag has the given prefix. |
void |
TaggedDigitizedOrderedCollectionWrapper.longestCommonPrefix(T tag,
Collection<? super TaggedElement<T,E>> tc)
|
void |
TaggedDigitizedOrderedCollection.longestCommonPrefix(T tag,
Collection<? super TaggedElement<T,E>> tc)
Adds to the provided tagged collection, tc , all tagged elements in this collection whose tag has a longest common
prefix with tag . |
Uses of Collection in goldman.collection.tagged.priority |
---|
Constructors in goldman.collection.tagged.priority with parameters of type Collection | |
---|---|
TaggedPriorityQueueWrapper(Collection<TaggedElement<T,E>> pairs)
|
Uses of Collection in goldman.collection.tagged.spatial |
---|
Methods in goldman.collection.tagged.spatial that return Collection | |
---|---|
Collection<TaggedElement<T,E>> |
TaggedSpatialCollectionWrapper.withinBounds(T minCorner,
T maxCorner)
|
Collection<TaggedElement<T,E>> |
TaggedSpatialCollection.withinBounds(T minCorner,
T maxCorner)
Returns a collection of the tagged elements for which the tag fall within (or on) the boundary of the multidimensional box defined by the two given corners, minCorner and maxCorner . |
Constructors in goldman.collection.tagged.spatial with parameters of type Collection | |
---|---|
TaggedSpatialCollectionWrapper(Collection<TaggedElement<T,E>> pairs)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |