@extends('layouts.TreeContainerLibrary')

@section('styles')
    <link media="all" type="text/css" rel="stylesheet" href="/assets/css/pages/tree-container-library/interface/associative-trees.css"/>
@stop

@section('panel-heading')
    <strong>Associative Trees</strong>
@stop

@section('content')
    <p>
        The associative trees consist of tree, multitree, and unique_tree. These trees are categorized as <dfn>associative trees</dfn>, because they all use associative containers (std::set) as their internal node
        containers. The forth tree container, sequential_tree, is a sequential type of tree, because it uses a std::vector as it's internal node
        container.
    </p>
    <p>
        The associative trees have many operations and properties in common. These operations are grouped below according to the type of operation. The
        documentation below applies to TCL versions 3.50 and higher. The latest version of the TCL can be downloaded from the <a href=
                                                                                                                                 '/download'>TCL download page</a>.
    </p>
    <h4>
        Removing Nodes
    </h4>
    <ul>
        <li>
            <em><code>bool <b>erase</b>(stored_type&amp; element)</code></em><br />
            This function varies slightly depending on the tree container which it's called. For a tree, the immediate children are searched. The return
            result indicates it's success. For a multitree, the immediate children are searched, and all occurences of the object are erased. The return
            result indicates if any node was erased. For a unique_tree, all descendants are searched. The return result indicates it's success.<br />
            <em>Complexity: Logarithmic</em>
        </li>
    </ul>
    <h4>
        Searching nodes
    </h4>
    <ul>
        <li>
            <em><code>iterator <b>find</b>(const stored_type&amp; element)</code></em><br />
            Searches child nodes for the <dfn>element</dfn>. Returns an iterator pointing
            to the found node, or the <code>end node</code> if unsuccessful. There is a slight variances in the behavior of the multitree container.
            Since multitree can have multiple occurences in a single parent, the iterator will return a pointer to the first found occurrence, or the end
            iterator if not found. Remember that when searching nodes, the <code>node_compare_type</code> will determine the equality of the node that's
            being sought.<br />
            <em>Complexity: Logarithmic</em>
        </li>
        <li>
            <em><code>const_iterator <b>find</b>(const stored_type&amp; element) const</code></em><br />
            Same as the above function, but returning a <code>const_iterator</code> rather than <code>iterator</code>.<br />
            <em>Complexity: Logarithmic</em>
        </li>
        <li>
            <em><code>size_type <b>count</b>(const stored_type&amp; element)</code></em><br />
            Returns the number of element's within the nodes children. Does not search in descendants.<br />
            <em>Complexity: Logarithmic</em>
        </li>
        <li>
            <em><code>iterator <b>lower_bound</b>(const stored_type&amp; element)</code></em><br />
            <em><code>const_iterator <b>lower_bound</b>(const_stored_type&amp; element)</code></em> const<br />
            Returns the first position where a copy of element would be inserted.<br />
            <em>Complexity: Logarithmic</em>
        </li>
        <li>
            <em><code>iterator <b>upper_bound</b>(const stored_type&amp; element)</code></em><br />
            <em><code>const_iterator <b>upper_bound</b>(const stored_type&amp; element)</code></em> const<br />
            Returns the last position where a copy of element would be inserted.<br />
            <em>Complexity: Logarithmic</em>
        </li>
        <li>
            <em><code>std::pair&lt;iterator, iterator&gt; <b>equal_range</b>(const stored_type&amp; element)</code></em><br />
            <em><code>std::pair&lt;const_iterator, const_iterator&gt; <b>equal_range</b>(const stored_type&amp; element)</code></em> const<br />
            Returns a pair which specify the first and last position where a copy of element would be inserted.<br />
            <em>Complexity: Logarithmic</em>
        </li>
    </ul>

@stop