mirror of https://github.com/CGAL/cgal
94 lines
2.9 KiB
TeX
94 lines
2.9 KiB
TeX
\begin{ccRefClass}{Union_find<T,A>}\ccCreationVariable{P}
|
|
|
|
\ccDefinition
|
|
|
|
An instance \ccc{P} of the data type \ccc{Union_find<T,A>} is a
|
|
partition of values of type \ccc{T} into disjoint sets. The template
|
|
parameter \ccc{A} has to be a model of the allocator concept as defined
|
|
in the C++ standard. It has a default argument \ccc{CGAL_ALLOCATOR(T)}.
|
|
|
|
|
|
\ccSetOneOfTwoColumns{6.5cm}
|
|
|
|
\ccTypes
|
|
|
|
\ccNestedType{value_type}{values stored in items (equal to \ccc{T}).}
|
|
|
|
\ccNestedType{handle}{handle to values.}
|
|
|
|
\ccNestedType{iterator}{iterator over values.}
|
|
|
|
There are also constant versions \ccc{const_handle} and \ccc{const_iterator}.
|
|
|
|
|
|
\ccNestedType{allocator}{allocator.}
|
|
|
|
\ccSetOneOfTwoColumns{6.5cm}
|
|
|
|
\ccCreation
|
|
|
|
\ccConstructor{Union_find<T,A>()}{creates an instance \ccc{P} of type
|
|
\ccc{Union_find<T,A>} and initializes it to the empty partition.}
|
|
|
|
\ccSetTwoOfThreeColumns{2cm}{4cm}
|
|
|
|
\ccOperations
|
|
|
|
\ccMethod{allocator get_allocator() ;}{the allocator of \ccc{P}.}
|
|
|
|
\ccMethod{std::size_t number_of_sets() ;}{returns the number of disjoint
|
|
sets of \ccc{P}. }
|
|
|
|
\ccMethod{std::size_t size() ;}{returns the number of values of \ccc{P}.}
|
|
|
|
\ccMethod{std::size_t bytes() ;}{returns the memory consumed by \ccc{P}.}
|
|
|
|
\ccMethod{std::size_t size( const_handle p) ;}{returns the size of the set
|
|
containing $p$.}
|
|
|
|
\ccMethod{void clear();}{reinitializes \ccc{P} to an empty partition.}
|
|
|
|
\ccMethod{handle make_set(const T& x);}{creates a new singleton set
|
|
containing \ccc{x} and returns a handle to it.}
|
|
|
|
\ccMethod{handle push_back(const T& x) ;}{same as \ccc{make_set(x)}.}
|
|
|
|
\pagebreak
|
|
\ccMethod{template <class Forward_iterator> void
|
|
insert(Forward_iterator first, Forward_iterator beyond) ;}{insert
|
|
the range of values referenced by \ccc{[first,beyond)}. \ccRequire
|
|
value type of \ccc{Forward_iterator} is \ccc{T}.}
|
|
|
|
\ccMethod{handle find(handle p) ;}{}
|
|
\ccGlue
|
|
\ccMethod{const_handle find( const_handle p) ;}{returns a
|
|
canonical handle of the set that contains \ccc{p}, i.e.,
|
|
\ccc{P.same_set(p,q)} iff \ccc{P.find(p)} and \ccc{P.find(q)}
|
|
return the same handle.
|
|
\ccPrecond \ccc{p} is a handle in \ccc{P}.}
|
|
|
|
\ccMethod{void unify_sets( handle p, handle q);}{unites the sets of
|
|
partition \ccc{P} containing $p$ and $q$. \ccPrecond $p$ and $q$ are
|
|
in \ccc{P}.}
|
|
|
|
\ccMethod{bool same_set( const_handle p, const_handle q) ;}{returns
|
|
true iff $p$ and $q$ belong to the same set of \ccc{P}.
|
|
\ccPrecond $p$ and $q$ are in \ccc{P}.}
|
|
|
|
\ccMethod{iterator begin() ;}{returns an iterator pointing to the
|
|
first value of \ccc{P}.}
|
|
|
|
\ccMethod{iterator end() ;}{returns an iterator pointing beyond the
|
|
last value of \ccc{P}. }
|
|
|
|
\ccImplementation
|
|
|
|
\ccc{Union_find<T,A>} is implemented with union by rank and path
|
|
compression. The running time for $m$ set operations on $n$ elements
|
|
is $O(n \alpha(m,n))$ where $\alpha(m,n)$ is the extremely slow growing
|
|
inverse of Ackermann's function.
|
|
|
|
\end{ccRefClass}
|
|
|
|
|