class HashSet<ValueType>
Set
class except for the fact that it uses a hash table as its underlying
representation. The advantage of the HashSet
class is that
it operates in constant time, as opposed to the O(log N)
time for the Set
class. The disadvantage of
HashSet
is that iterators return the values in a
seemingly random order.
Constructor  
O(1)  Initializes an empty set of the specified element type.  
Methods  
O(1)  Adds an element to this set, if it was not already there.  
O(N)  Removes all elements from this set.  
O(1)  Returns true if the specified value is in this set. 

O(N)  Returns true if the two sets contain the same elements. 

O(1)  Returns the first value in the set in the order established by a foreach loop.  
O(1)  Returns true if this set contains no elements. 

O(N)  Implements the subset relation on sets.  
O(N)  Iterates through the elements of the set and calls fn(value) for each one. 

O(1)  Removes an element from this set.  
O(1)  Returns the number of elements in this set.  
O(N)  Converts the set to a printable string representation.  
Operators  
O(N)  Returns true if set1 and set2 contain the same elements. 

O(N)  Returns true if set1 and set2 are different. 

O(N)  Returns the union of sets set1 and set2 , which is the set of elements that appear in at least one of the two sets. 

O(N)  Returns the union of set set1 and individual value value . 

O(N)  Adds all of the elements from set2 (or the single specified value) to set1 . 

O(1)  Adds the single specified value to the set.  
O(N)  Returns the difference of sets set1 and set2 , which is all of the elements that appear in set1 but not set2 . 

O(N)  Returns the set set with value removed. 

O(N)  Removes the elements from set2 (or the single specified value) from set1 . 

O(1)  Removes the single specified value from the set.  
O(N)  Returns the intersection of sets set1 and set2 , which is the set of all elements that appear in both. 

O(N)  Removes any elements from set1 that are not present in set2 . 

O(N)  Outputs the contents of the set to the given output stream.  
O(N)  Reads the contents of the given input stream into the set. 
HashSet();
Usage:
HashSet<ValueType> set;
void add(ValueType value); void insert(ValueType value);
set
class, this method
is also exported as insert
.
Usage:
set.add(value);
void clear();
Usage:
set.clear();
bool contains(ValueType value) const;
true
if the specified value is in this set.
Usage:
if (set.contains(value)) ...
bool equals(const HashSet& grid) const;
true
if the two sets contain exactly the same element values.
Identical in behavior to the ==
operator.
Usage:
if (set.equals(set2)) ...
ValueType first() const;
first
generates an error.
Usage:
ValueType value = set.first();
bool isEmpty() const;
true
if this set contains no elements.
Usage:
if (set.isEmpty()) ...
bool isSubsetOf(const HashSet& set2) const;
true
if every element of this set is
contained in set2
.
Usage:
if (set.isSubsetOf(set2)) ...
void mapAll(void (*fn)(ValueType)) const; void mapAll(void (*fn)(const ValueType&)) const; void mapAll(FunctorType fn) const;
fn(value)
for each one. The values are processed in ascending order, as defined
by the comparison function.
Usage:
set.mapAll(fn);
void remove(ValueType value);
Usage:
set.remove(value);
int size() const;
Usage:
count = set.size();
string toString();
"{value1, value2, value3}"
.
The values appear in an unpredictable order.
Usage:
string str = set.toString();
bool operator==(const HashSet& set2) const;
true
if set1
and set2
contain the same elements.
Usage:
set1 == set2
bool operator!=(const HashSet& set2) const;
true
if set1
and set2
are different.
Usage:
set1 != set2
HashSet operator+(const HashSet& set2) const; HashSet operator+(ValueType element) const;
set1
and set2
, which
is the set of elements that appear in at least one of the two sets. The
right hand set can be replaced by an element of the value type, in which
case the operator returns a new set formed by adding that element.
Usage:
set1 + set2 set1 + element
HashSet operator*(const HashSet& set2) const;
set1
and set2
,
which is the set of all elements that appear in both.
Usage:
set1 * set2
HashSet operator(const HashSet& set2) const; HashSet operator(ValueType element) const;
set1
and set2
,
which is all of the elements that appear in set1
but
not set2
. The right hand set can be replaced by an
element of the value type, in which case the operator returns a new
set formed by removing that element.
Usage:
set1  set2 set1  element
HashSet& operator+=(const HashSet& set2); HashSet& operator+=(ValueType value);
set2
(or the single
specified value) to set1
. As a convenience, the
HashSet
package also overloads the comma operator so
that it is possible to initialize a set like this:
HashSet<int> digits; digits += 0, 1, 2, 3, 4, 5, 6, 7, 8, 9;
Usage:
set1 += set2; set1 += value;
HashSet& operator*=(const HashSet& set2);
set1
that are not present in
set2
.
Usage:
set1 *= set2;
HashSet& operator=(const HashSet& set2); HashSet& operator=(ValueType value);
set2
(or the single
specified value) from set1
. As a convenience, the
HashSet
package also overloads the comma operator so
that it is possible to remove multiple elements from a set
like this:
digits = 0, 2, 4, 6, 8;which removes the values 0, 2, 4, 6, and 8 from the set
digits
.
Usage:
set1 = set2; set1 = value;