class Set<ValueType>
The set uses a binary search tree (BST) structure internally.
Because of this choice of internal representation, the ValueType
for the type of elements stored in a Set
must define a natural ordering through a less
function and/or <
operator so that the elements can be compared and ordered.
Constructor  
O(1)  Creates an empty set of the specified element type.  
Methods  
O(log N)  Adds an element to this set, if it was not already there.  
O(N)  Removes all elements from this set.  
O(log N)  Returns true if the specified value is in this set. 

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

O(log N)  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(log N)  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(log N)  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(log N)  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 log N)  Reads the contents of the given input stream into the set. 
Set();
Usage:
Set<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 Set& 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 Set& 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() const;
"{value1, value2, value3}"
.
The values will be listed in ascending order.
Usage:
string str = set.toString();
bool operator==(const Set& set2) const;
true
if set1
and set2
contain the same elements.
Usage:
set1 == set2
bool operator!=(const Set& set2) const;
true
if set1
and set2
are different.
Usage:
set1 != set2
Set operator+(const Set& set2) const; Set 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
Set operator*(const Set& set2) const;
set1
and set2
,
which is the set of all elements that appear in both.
Usage:
set1 * set2
Set operator(const Set& set2) const; Set 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
Set& operator+=(const Set& set2); Set& operator+=(ValueType value);
set2
(or the single
specified value) to set1
. As a convenience, the
Set
package also overloads the comma operator so
that it is possible to initialize a set like this:
Set<int> digits; digits += 0, 1, 2, 3, 4, 5, 6, 7, 8, 9;
Usage:
set1 += set2; set1 += value;
Set& operator*=(const Set& set2);
set1
that are not present in
set2
.
Usage:
set1 *= set2;
Set& operator=(const Set& set2); Set& operator=(ValueType value);
set2
(or the single
specified value) from set1
. As a convenience, the
Set
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;