/*sort all elements
 *-n+n*log(n) complexity
 */
make_heap (coll.begin(), coll.end());
sort_heap (coll.begin(), coll.end());

// algo/find1.cpp

    #include "algostuff.hpp"
    using namespace std;

    int main()
    {

        list<int> coll;

        INSERT_ELEMENTS(coll,1,9);
        INSERT_ELEMENTS(coll,1,9);

        PRINT_ELEMENTS(coll,"coll: ");

        // find first element with value 4
        list<int>::iterator pos1;
        pos1 = find (coll.begin(), coll.end(),    // range
                     4);                          // value
/*find second element with value 4
         *- note: continue the search behind the first 4 (if any)
*/
        list<int>::iterator pos2;
        if (pos1 != coll.end()) {
            pos2 = find (++pos1, coll.end(),      // range
                         4);                      // value
        }

        /*print all elements from first to second 4 (both included)
*- note: now we need the position of the first 4 again (if any)
*- note: we have to pass the position behind the second 4 (if any)
*/
        if (pos1!=coll.end() && pos2!=coll.end()) {
            copy (--pos1, ++pos2,
                  ostream_iterator<int>(cout," "));
            cout << endl;
        }
    }

    coll: 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9
    4 5 6 7 8 9 1 2 3 4

// algo/find2.cpp

    #include "algostuff.hpp"
    using namespace std;

    int main()
    {

        vector<int> coll;
        vector<int>::iterator pos;

        INSERT_ELEMENTS(coll,1,9);

        PRINT_ELEMENTS(coll,"coll: ");

        // find first element greater than 3
        pos = find_if (coll.begin(), coll.end(),        // range
                       bind2nd(greater<int>(),3));      // criterion
// print its position

        cout << "the "
             << distance(coll.begin(),pos) + 1
             << ". element is the first greater than 3" << endl;

        // find first element divisible by 3
        pos = find_if (coll.begin(), coll.end(),
                       not1(bind2nd(modulus<int>(),3)));

        // print its position
        cout << "the "
             << distance(coll.begin(),pos) + 1
             << ". element is the first divisible by 3" << endl;
    }

    coll: 1 2 3 4 5 6 7 8 9
    the 4. element is the first greater than 3
    the 3. element is the first divisible by 3

// algo/searchn1.cpp

    #include "algostuff.hpp"
    using namespace std;

    int main()
    {

        deque<int> coll;

        INSERT_ELEMENTS(coll,1,9);
        PRINT_ELEMENTS(coll);

        // find four consecutive elements with value 3
        deque<int>::iterator pos;
        pos = search_n (coll.begin(), coll.end(),   // range
                        4,                          // count
                        3);                         // value
// print result
        if (pos != coll.end()) {
            cout << "four consecutive elements with value 3 "
                 << "start with " << distance(coll.begin(),pos) +1
                 << ". element" << endl;
        }
        else {
            cout << "no four consecutive elements with value 3 found"
                 << endl;
        }

        // find four consecutive elements with value greater than 3
        pos = search_n (coll.begin(), coll.end(),                   // range
                        4,                                          // count
                        3,                                          // value
                        greater<int>());                            // criterion
// print result
        if (pos != coll.end()) {
            cout << "four consecutive elements with value > 3 "
                 << "start with " << distance(coll.begin(),pos) +1
                 << ". element" << endl;

        }
        else {
            cout << "no four consecutive elements with value > 3 found"
                 << endl;
        }
    }

    1 2 3 4 5 6 7 8 9
    no four consecutive elements with value 3 found
    four consecutive elements with value > 3 start with 4. element

    pos = search_n (coll.begin(), coll.end(),   // range
                    4,                          // count
                    3,                          // value
                    greater<int>());            // criterion

    pos = search_n_if (coll.begin(), coll.end(),       // range
                       4,                              // count
                       bind2nd(greater<int>(),3));     // criterion

    bool isPrime (int elem);
    ...
    pos = search_n_if (coll.begin(), coll.end(),   // range
                       4,                          // count
                       isPrime);                   //criterion

    bool binaryIsPrime (int elem1, int) {
        return isPrime(elem1);
    }
    ...
    pos = search_n (coll.begin(), coll.end(),     // range
                    4,                            // count
                    0,                            // required dummy value
                    binaryIsPrime);               // binary criterion

// algo/search1.cpp

    #include "algostuff.hpp"
    using namespace std;

    int main()
    {

        deque<int> coll;
        list<int> subcoll;

        INSERT_ELEMENTS(coll,1,7);
        INSERT-ELEMENTS(coll,1,7);

        INSERT_ELEMENTS(subcoll,3,6);

        PRINT_ELEMENTS(coll, "coll: ");
        PRINT_ELEMENTS(subcoll,"subcoll: ");

        // search first occurrence of subcoll in coll
        deque<int>::iterator pos;
        pos = search (coll.begin(), coll.end(),            // range
                      subcoll.begin(), subcoll.end());     //subrange
// loop while subcoll found as subrange of coll
        while (pos != coll.end()) {
            // print position of first element
            cout << "subcoll found starting with element "
                 << distance(coll.begin(),pos) + 1
                 << endl;

            // search next occurrence of subcoll
            ++pos;
            pos = search (pos, coll.end(),                  // range
                          subcoll.begin(), subcoll.end());  // subrange
        }
    }

    coll: 1 2 3 4 5 6 7 1 2 3 4 5 6 7
    subcoll: 3 4 5 6
    subcoll found starting with element 3
    subcoll found starting with element 10

// algo/search2.cpp

    #include "algostuff.hpp"
    using namespace std;

    // checks whether an element is even or odd
    bool checkEven (int elem, bool even)
    {

        if (even) {
            return elem % 2 == 0;
        }
        else {
            return elem % 2 == 1;
        }
    }

    int main()
    {

        vector<int> coll;

        INSERT_ELEMENTS(coll,1,9);
        PRINT_ELEMENTS(coll,"coll: ");

        /* arguments for checkEven()
         * - check for: "even odd even"
*/
        bool checkEvenArgs[3] = { true, false, true };

        // search first subrange in coll
        vector<int>::iterator pos;
        pos = search (coll.begin(), coll.end(),       // range
                      checkEvenArgs, checkEvenArgs+3, // subrange values
                      checkEven);                     // subrange criterion
// loop while subrange found
        while (pos != coll.end()) {
            // print position of first element
            cout << "subrange found starting with element "
                 << distance(coll.begin(),pos) + 1
                 << endl;

            // search next subrange in coll
            pos = search (++pos, coll.end(),               // range
                          checkEvenArgs, checkEvenArgs+3,  // subr. values
                          checkEven);                      // subr. criterion
        }
    }

    coll: 1 2 3 4 5 6 7 8 9
    subrange found starting with element 2
    subrange found starting with element 4
    subrange found starting with element 6

// algo/findend1.cpp

    #include "algostuff.hpp"
    using namespace std;

    int main()
    {

        deque<int> coll;
        list<int> subcoll;

        INSERT_ELEMENTS(coll,1,7);
        INSERT_ELEMENTS(coll,1,7);

        INSERT_ELEMENTS(subcoll,3,6);

        PRINT_ELEMENTS(coll,   "coll:    ");
        PRINT_ELEMENTS(subcoll,"subcoll: ");

        // search last occurrence of subcoll in coll
        deque<int>::iterator pos;
        pos = find_end (coll.begin(), coll.end(),         // range
                        subcoll.begin(), subcoll.end());  // subrange
// loop while subcoll found as subrange of coll
        deque<int>::iterator end(coll.end());
        while (pos != end) {
            // print position of first element
            cout << "subcoll found starting with element "
                 << distance(coll.begin(),pos) + 1
                 << endl;

            // search next occurrence of subcoll
            end = pos;
            pos = find_end (coll.begin(), end,                // range
                            subcoll.begin(), subcoll.end());  // subrange
        }
    }

    coll:    1 2 3 4 5 6 7 1 2 3 4 5 6 7
    subcoll: 3 4 5 6
    subcoll found starting with element 10
    subcoll found starting with element 3

// algo/findof1.cpp

    #include "algostuff.hpp"
    using namespace std;

    int main()
    {

        vector<int> coll;
        list<int> searchcoll;

        INSERT_ELEMENTS(coll,1,11);
        INSERT_ELEMENTS(searchcoll,3,5);

        PRINT_ELEMENTS(coll,      "coll:       ");
        PRINT_ELEMENTS(searchcoll,"searchcoll: ");

        // search first occurrence of an element of searchcoll in coll
        vector<int>::iterator pos;
        pos = find_first_of (coll.begin(), coll.end(),     // range
                             searchcoll.begin(),  // beginning of search set
                             searchcoll.end());   // end of search set
        cout << "first element of searchcoll in coll is element "
             << distance(coll.begin(),pos) + 1
             << endl;

        // search last occurrence of an element of searchcoll in coll
        vector<int>::reverse_iterator rpos;
        rpos = find_first_of (coll.rbegin(), coll.rend(),   // range
                              searchcoll.begin(),  // beginning of search set
                              searchcoll.end());   // end of search set
        cout << "last element of searchcoll in coll is element "
             << distance (coll.begin(),rpos.base())
             << endl;
    }

    coll:       1 2 3 4 5 6 7 8 9 10 11
    searchcoll: 3 4 5
    first element of searchcoll in coll is element 3
    last element of searchcoll in coll is element 5

// algo/adjfindl.cpp

    #include "algostuff.hpp"
    using namespace std;

    // return whether the second object has double the value of the first
    bool doubled (int elem1, int elem2)
    {
        return elem1 * 2 == elem2;
    }

    int main()
    {

        vector<int> coll;

        coll.push_back(1);
        coll.push_back(3);
        coll.push_back(2);
        coll.push_back(4);
        coll.push_back(5);
        coll.push_back(5);
        coll.push_back(0);

        PRINT_ELEMENTS(coll,"coll: ");

        // search first two elements with equal value
        vector<int>::iterator pos;
        pos = adjacent_find (coll.begin(), coll.end());

        if (pos != coll.end()) {
            cout << "first two elements with equal value have position "
                 << distance(coll.begin(),pos) + 1
                 << endl;
        }

        //search first two elements for which the second has double the value of the first
        pos = adjacent_find (coll.begin(), coll.end(),   // range
                             doubled);                   // criterion

        if (pos != coll.end()) {
            cout << "first two elements with second value twice the "
                 << "first have pos. "
                 << distance(coll.begin(),pos) + 1
                 << endl;
        }
    }

    coll: 1 3 2 4 5 5 0
    first two elements with equal value have position 5
    first two elements with second value twice the first have pos. 3

// algo/equal1.cpp

    #include "algostuff.hpp"
    using namespace std;
    bool bothEvenOrOdd (int elem1, int elem2)
    {
        return elem1 % 2 == elem2 % 2;
    }


    int main()
    {

        vector<int> coll1;
        list<int> coll2;


        INSERT_ELEMENTS(coll1,1,7);
        INSERT_ELEMENTS(coll2,3,9);


        PRINT_ELEMENTS(coll1,"coll1: ");
        PRINT_ELEMENTS(coll2,"coll2: ");


        //check whether both collections are equal
        if (equal (coll1.begin(), coll1.end(),  //first range
                   coll2.begin())) {              //second range
            cout << "coll1 == coll2" << endl;
        }
        else {
            cout << "coll1 != coll2" << endl;
        }


        //check for corresponding even and odd elements
        if (equal (coll1.begin(), coll1.end(),   //first range
                   coll2.begin(),               //second range
                   bothEvenOrOdd)) {             //comparison criterion
            cout << "even and odd elements correspond" << endl;
        }
        else {
            cout << "even and odd elements do not correspond" << endl;
        }
    }

    coll1: 1 2 3 4 5 6 7
    coll2: 3 4 5 6 7 8 9
    coll1 != coll2
    even and odd elements correspond

// algo/misma1.cpp

    #include "algostuff.hpp"
    using namespace std;

    int main()
    {

        vector<int> coll1;
        list<int> coll2;

        INSERT_ELEMENTS(coll1,1,6);

        for (int i=1; i<=16; i*=2) {
            coll2.push_back(i);
        }
        coll2.push_back(3);

        PRINT_ELEMENTS(coll1,"coll1: ");
        PRINT_ELEMENTS(coll2,"coll2: ");

        //find first mismatch
        pair<vector<int>::iterator,list<int>::iterator> values;
        values = mismatch (coll1.begin(), coll1.end(),  //first range
                           coll2.begin());              //second range
        if (values.first == coll1.end()) {
            cout << "no mismatch" << endl;
        }
        else {
            cout << "first mismatch: "
                 << *values.first << " and "
                 << *values.second << endl;
        }

        /*find first position where the element of coll1 is not
*less than the corresponding element of coll2
         */
        values = mismatch (coll1.begin(), coll1.end(),   //first range
                           coll2.begin(),               //second range
                           less_equal<int>())           //criterion
        if (values.first == coll1.end()) {
            cout << "always less-or-equal" << endl;
        }
        else {
            cout << "not less-or-equal: "
                 << *values.first << " and "
                 << *values.second << endl;
        }
    }

    coll1: 1 2 3 4 5 6
    coll2: 1 2 4 8 16 3
    first mismatch: 3 and 4
    not less-or-equal: 6 and 3

// algo/lexico1.cpp

   #include "algostuff.hpp"
   using namespace std;
   void printCollection (const list<int>& 1)
   {
       PRINT_ELEMENTS(1);
   }

   bool lessForCollection (const list<int>& 11, const list<int>& 12)
   {
      return lexicographical_compare
                  (11.begin(), 11.end(),    // first range
                   12.begin(), 12.end());   // second range
   }

   int main()
   {
       list<int> c1, c2, c3, c4;

       //fill all collections with the same starting values
       INSERT_ELEMENTS(c1,1,5);
       c4 = c3 = c2 = c1;

       //and now some differences
       c1.push_back(7);
       c3.push_back(2);
       c3.push_back(0);
       c4.push_back(2);

       //create collection of collections
       vector<list<int> > cc;

       cc.push_back(c1);
       cc.push_back(c2);
       cc.push_back(c3);
       cc.push_back(c4);
       cc.push_back(c3);
       cc.push_back(c1);
       cc.push_back(c4);
       cc.push_back(c2);

       //print all collections
       for_each (cc.begin(), cc.end(),
                 printCollection);
       cout << endl;

       //sort collection lexicographically
       sort (cc.begin(), cc.end(),       //range
             lessForCollection);        //sorting criterion
//print all collections again
       for_each (cc.begin(), cc.end(),
                 printCollection);
   }

   1 2 3 4 5 7
   1 2 3 4 5
   1 2 3 4 5 2 0
   1 2 3 4 5 2
   1 2 3 4 5 2 0
   1 2 3 4 5 7
   1 2 3 4 5 2
   1 2 3 4 5

   1 2 3 4 5
   1 2 3 4 5
   1 2 3 4 5 2
   1 2 3 4 5 2
   1 2 3 4 5 2 0
   1 2 3 4 5 2 0
   1 2 3 4 5 7
   1 2 3 4 5 7

// algo/transf1.cpp

   #include "algostuff.hpp"
   using namespace std;

   int main()
   {
       vector<int> coll1;
       list<int> coll2;

       INSERT_ELEMENTS(coll1,1,9);
       PRINT_ELEMENTS(coll1,"coll1: ");

       //negate all elements in coll1
       transform (coll1.begin(), coll1.end(),           //source range
                  coll1.begin(),                        //destination range
                  negate<int>());                       //operation


       PRINT_ELEMENTS(coll1,"negated: ");


       //transform elements of coll1 into coll2 with ten times their value
       transform (coll1.begin(), coll1.end(),            //source range
                  back_inserter(coll2),                  //destination range
                  bind2nd(multiplies<int>(),10));        //operation
       PRINT_ELEMENTS(coll2,"coll2: ");


       //print coll2 negatively and in reverse order
       transform (coll2.rbegin(), coll2.rend(),          //source range
                  ostream_iterator<int>(cout," "),       //destination range
                  negate<int>());                        //operation
       cout << endl;
   }

   coll1:    1  2 3 4 5 6 7 8 9
   negated: −1 −2 −3 −4 −5 −6 −7 −8 −9
   coll2:   −10 −20 −30 −40 −50 −60 −70 −80 −90
   90 80 70 60 50 40 30 20 10

// algo/transf2.cpp

   #include "algostuff.hpp"
   using namespace std;

   int main()
   {
       vector<int> coll1;
       list<int> coll2;

       INSERT_ELEMENTS(coll1,1,9);
       PRINT_ELEMENTS(coll1,"coll1:    ");

       //square each element
       transform (coll1.begin(), coll1.end(),           //first source range
                  coll1.begin(),                        //second source range
                  coll1.begin(),                        //destination range
                  multiplies<int>() );                  //operation
       PRINT_ELEMENTS(coll1,"squared: ");

       /*add each element traversed forward with each element traversed backward
*and insert result into coll2
        */
       transform (coll1. begin(), coll1. end(),         //first source range
                  coll1.rbegin(),                       //second source range
                  back_inserter(coll2),                 //destination range
                  plus<int>());                         //operation
       PRINT_ELEMENTS(coll2,"coll2: ");

       // print differences of two corresponding elements
       cout << "diff: ";
       transform (coll1.begin(), coll1.end(),           //first source range
                  coll2.begin(),                        //second source range
                  ostream_iterator<int>(cout, " "),     //destination range
                  minus<int>());                        //operation
       cout << endl;
   }

   coll1:    1 2 3 4 5 6 7 8 9
   squared:  1 4 9 16 25 36 49 64 81
   coll2:    82 68 58 52 50 52 58 68 82
   diff:     −81 −64 −49 −36 −25 −16 −9 −4 −1

// algo/fill1.cpp

   #include "algostuff.hpp"
   using namespace std;

   int main()
   {
       //print ten times 7.7
       fill_n(ostream_iterator<float>(cout, " "), //beginning of destination
              10,                                 //count
              7.7);                               //new value
       cout << endl;

       list<string> coll;

       //insert "hello" nine times
       fill_n(back_inserter(coll),         //beginning of destination
              9,                           //count
              "hello");                    //new value 
       PRINT_ELEMENTS(coll,"coll: ");


       //overwrite all elements with "again"
       fill(coll.begin(), coll.end(),      //destination
            "again");                      //new value
       PRINT_ELEMENTS(coll,"coll: ");


       //replace all but two elements with "hi"
       fill_n(coll.begin(),                //beginning of destination
              coll.size()-2,            //count
              "hi");                       //new value
       PRINT_ELEMENTS(coll,"coll: ");


       //replace the second and up to the last element but one with "hmmm"
       list<string>:: iterator pos1, pos2;
       pos1 = coll.begin();
       pos2 = coll.end();
       fill (++pos1, --pos2,               //destination
             "hmmm");                      //new value
       PRINT_ELEMENTS(coll,"coll: ");
   }

   7.7 7.7 7.7 7.7 7.7 7.7 7.7 7.7 7.7 7.7
   coll: hello hello hello hello hello hello hello hello hello
   coll: again again again again again again again again again
   coll: hi hi hi hi hi hi hi again again
   coll: hi hmmm hmmm hmmm hmmm hmmm hmmm hmmm again

// algo/generate.cpp

   #include <cstdlib>
   #include "algostuff.hpp"
   using namespace std;

   int main()
   {
       list<int> coll;

       //insert five random numbers
       generate_n (back_inserter(coll),       //beginning of destination range
                   5,                         //count
                   rand);                     //new value generator
       PRINT_ELEMENTS(coll);

       //overwrite with five new random numbers
       generate (coll.begin(), coll.end(),    //destination range
                 rand);                       //new value generator
       PRINT_ELEMENTS(coll);
   }

   41 18467 6334 26500 19169
   15724 11478 29358 26962 24464

// algo/replace1.cpp

   #include "algostuff.hpp"
   using namespace std;

   int main()
   {
       list<int> coll;

       INSERT_ELEMENTS(coll,2,7);
       INSERT_ELEMENTS(coll,4,9);
       PRINT_ELEMENTS(coll,"coll: ");

       //replace all elements with value 6 with 42
       replace (coll.begin(), coll.end(),      //range
                6,                             //old value
                42);                           //new value
       PRINT_ELEMENTS(coll,"coll: ");

       //replace all elements with value less than 5 with 0
       replace_if (coll.begin(), coll.end(),   //range
                   bind2nd(less<int>(),5),     //criterion for replacement
                   0);                         //new value
       PRINT_ELEMENTS(coll,"coll: ");
   }

   coll: 2 3 4 5 6 7 4 5 6 7 8 9
   coll: 2 3 4 5 42 7 4 5 42 7 8 9
   coll: 0 0 0 5 42 7 0 5 42 7 8 9

// algo/replace2.cpp

   #include "algostuff.hpp"
   using namespace std;

   int main()
   {
       list<int> coll;

       INSERT_ELEMENTS(coll,2,6);
       INSERT_ELEMENTS(coll,4,9);
       PRINT_ELEMENTS(coll);

       // print all elements with value 5 replaced with 55
       replace_copy(coll.begin(), coll.end(),                // source
                    ostream_iterator<int>(cout," "),         //destination
                    5,                                       // old value
                    55);                                     // new value
       cout << endl;

       // print all elements with a value less than 5 replaced with 42
       replace_copy_if (coll.begin(), coll.end(),           // source
                        ostream_iterator<int>(cout," "),    // destination
                        bind2nd(less<int>(),5),    // replacement criterion
                        42);                       // new value
       cout << endl;

       //print each element while each odd element is replaced with 0
       replace_copy_if (coll.begin(), coll.end(),           // source
                        ostream_iterator<int>(cout," "),    //destination
                        bind2nd (modulus<int>(),2), // replacement criterion
                        0);                         // new value
                        cout << endl;
   }

   2 3 4 5 6 4 5 6 7 8 9
   2 3 4 55 6 4 55 6 7 8 9
   42 42 42 5 6 42 5 6 7 8 9
   2 0 4 0 6 4 0 6 0 8 0

// algo/remove1.cpp

   #include "algostuff.hpp"
   using namespace std;

   int main()
   {
       vector<int> coll;

       INSERT_ELEMENTS(coll,2,6);
       INSERT_ELEMENTS(coll,4,9);
       INSERT_ELEMENTS(coll,1,7);
       PRINT_ELEMENTS(coll,"coll:                  ");

       //remove all elements with value 5
       vector<int>::iterator pos;
       pos = remove (coll.begin(), coll.end(),    // range
                     5);                           // value to remove

       PRINT_ELEMENTS(coll,"size not changed:      ");

       //erase the "removed" elements in the container
       coll. erase (pos, coll.end());
       PRINT_ELEMENTS(coll,"size changed:          ");

       //remove all elements less than 4
       coll.erase(remove_if (coll.begin(), coll.end(),       // range
                             bind2nd(less<int>(),4)),        // remove criterion
                  coll.end());
       PRINT_ELEMENTS(coll,"<4 removed: ");
   }

   coll:                  2 3 4 5 6 4 5 6 7 8 9 1 2 3 4 5 6 7
   size not changed:      2 3 4 6 4 6 7 8 9 1 2 3 4 6 7 5 6 7
   size changed:          2 3 4 6 4 6 7 8 9 1 2 3 4 6 7
   <4 removed:           4 6 4 6 7 8 9 4 6 7

// algo/unique1.cpp

   #include "algostuff.hpp"
   using namespace std;

   int main()
   {
       //source data
       int source[] = { 1, 4, 4, 6, 1, 2, 2, 3, 1, 6, 6, 6, 5, 7,
                         5, 4, 4 };
       int sourceNum = sizeof(source)/sizeof(source[0]);

       list<int> coll;

       //initialize coll with elements from source
       copy (source, source+sourceNum,               //source
             back_inserter(coll)) ;                  //destination
       PRINT_ELEMENTS(coll);

       //remove consecutive duplicates
       list<int>::iterator pos;

       pos = unique (coll.begin(), coll.end());

       /* print elements not removed
* - use new logical end
*/
       copy (coll.begin(), pos,                      //source
             ostream_iterator<int>(cout," "));       //destination
       cout << "

";

       //reinitialize coll with elements from source
       copy (source, source+sourceNum,               //source
             coll.begin());                          //destination
       PRINT_ELEMENTS(coll);

       //remove elements if there was a previous greater element
       coll.erase (unique (coll.begin(), coll.end(),
                           greater<int>()), 
                   coll.end()); 
       PRINT_ELEMENTS(coll);
   }

   1 4 4 6 1 2 2 3 1 6 6 6 5 7 5 4 4
   1 4 6 1 2 3 1 6 5 7 5 4

   1 4 4 6 1 2 2 3 1 6 6 6 5 7 5 4 4
   1 4 4 6 6 6 6 7

// algo/unique2.cpp

   #include "algostuff.hpp"
   using namespace std;


   bool differenceOne (int elem1, int elem2)
   {

       return elem1 + 1 == elem2 || elem1 - 1 == elem2;

   }


   int main()
   {

       // source data
       int source [] = { 1, 4, 4, 6, 1, 2, 2, 3, 1, 6, 6, 6, 5, 7, 
                         5, 4, 4 };
       int sourceNum = sizeof(source)/sizeof(source[0]);


       // initialize coll with elements from source
       list<int> coll;
       copy(source, source+sourceNum,                  // source
            back_inserter(coll));                      // destination
       PRINT_ELEMENTS(coll);


       // print elements with consecutive duplicates removed
       unique_copy(coll.begin(), coll.end(),              // source
                   ostream_iterator<int>(cout," "));      // destination
       cout << endl;


       // print elements without consecutive duplicates that differ by one
       unique_copy(coll.begin(), coll.end(),              // source
                   ostream_iterator<int>(cout," "),       // destination
                   differenceOne);                        // duplicates criterion
       cout << endl;
   }

   1 4 4 6 1 2 2 3 1 6 6 6 5 7 5 4 4
   1 4 6 1 2 3 1 6 5 7 5 4
   1 4 4 6 1 3 1 6 6 6 4 4

// algo/unique3.cpp

    #include <iostream>
    #include <algorithm>
    using namespace std;


    bool bothSpaces (char elem1, char elem2)
    {

        return elem1 == ' ' && elem2 == ' ';

    }


    int main()
    {

        // don't skip leading whitespaces by default
        cin.unsetf(ios::skipws);
        / * copy standard input to standard output
* - while compressing spaces
*/
        unique_copy(istream_iterator<char>(cin),      // beginning of source: cin
                    istream_iterator<char>(),         // end of source: end-of-file
                    ostream_iterator<char>(cout),     // destination: cout
                    bothSpaces);                      // duplicate criterion
   }

   Hello, here are sometimes more and sometimes fewer spaces.

   Hello, here are sometimes more and sometimes fewer spaces.

// algo/rotate1.cpp

   #include "algostuff.hpp"
   using namespace std;


   int main()
   {

       vector<int> coll;


       INSERT_ELEMENTS(coll,1,9);
       PRINT_ELEMENTS(coll,"coll:           ");


       // rotate one element to the left
       rotate (coll.begin(),        // beginning of range
               coll.begin() + 1,    // new first element
               coll.end());         // end of range
       PRINT_ELEMENTS(coll,"one left: ");


       // rotate two elements to the right
       rotate (coll.begin(),        // beginning of range
               coll.end() - 2,   // new first element
               coll.end());         // end of range
       PRINT_ELEMENTS(coll,"two right: ");


       // rotate so that element with value 4 is the beginning
       rotate (coll.begin(),                         // beginning of range
               find (coll.begin(), coll.end(),4),    // new first element
               coll.end());                          // end of range
       PRINT_ELEMENTS(coll,"4 first: ");
   }

   coll:      1 2 3 4 5 6 7 8 9
   one left:  2 3 4 5 6 7 8 9 1
   two right: 9 1 2 3 4 5 6 7 8
   4 first:   4 5 6 7 8 9 1 2 3

// algo/rotate2.cpp

   #include "algostuff.hpp"
   using namespace std;


   int main()
   {

      set<int> coll;


      INSERT_ELEMENTS(coll,1,9);
      PRINT_ELEMENTS(coll);


      // print elements rotated one element to the left
      set<int>::iterator pos = coll.begin();
      advance(pos,1);
      rotate_copy (coll.begin(),                        // beginning of source
                   pos,                                 // new first element
                   coll.end(),                          // end of source
                   ostream_iterator<int>(cout," "));    // destination
      cout << end1;


      // print elements rotated two elements to the right
      pos = coll.end();
      advance(pos,−2);
      rotate_copy(coll.begin(),                        // beginning of source
                  pos,                                 // new first element
                  coll.end(),                          // end of source
                  ostream_iterator<int>(cout," "));    // destination
      cout << end1;


      // print elements rotated so that element with value 4 is the beginning
      rotate_copy (coll.begin(),                        // beginning of source
                   coll.find(4),                        // new first element
                   coll.end(),                          // end of source
                   ostream_Iiterator<int>(cout," "));    // destination
      cout << end1; 
   }

   1 2 3 4 5 6 7 8 9
   2 3 4 5 6 7 8 9 1
   8 9 1 2 3 4 5 6 7
   4 5 6 7 8 9 1 2 3

// algo/heap1.cpp

   #include "algostuff.hpp"
   using namespace std;

   int main()
   {

       vector<int> coll;

       INSERT_ELEMENTS(coll,3,7);
       INSERT_ELEMENTS(coll,5,9); 
       INSERT_ELEMENTS(coll,1,4);

       PRINT_ELEMENTS (coll, "on entry:          ");

       // convert collection into a heap
       make_heap (coll.begin(), coll.end());

       PRINT_ELEMENTS (coll, "after make_heap(): ");

       // pop next element out of the heap
       pop_heap (coll.begin(), coll.end());
       coll.pop_back();

       PRINT_ELEMENTS (coll, "after pop_heap():  ");

       // push new element into the heap
       coll.push_back (17);
       push_heap (coll.begin(), coll.end());

       PRINT_ELEMENTS (coll, "after push_heap(): ");

       /*convert heap into a sorted collection
* - NOTE: after the call it is no longer a heap
*/
       sort_heap (coll.begin(), coll.end());

       PRINT_ELEMENTS (coll, "after sort_heap(): ");
   }

   on entry:           3 4 5 6 7 5 6 7 8 9 1 2 3 4
   after make_heap():  9 8 6 7 7 5 5 3 6 4 1 2 3 4
   after pop_heap():   8 7 6 7 4 5 5 3 6 4 1 2 3
   after push_heap():  17 7 8 7 4 5 6 3 6 4 1 2 3 5
   after sort_heap():  1 2 3 3 4 4 5 5 6 6 7 7 8 17

9 8 6 7 7 5 5 3 6 4 1 2 3 4

// algo/bsearch1.cpp

    #include "algostuff.hpp"
    using namespace std;

    int main()
    {

       list<int> coll;

       INSERT_ELEMENTS(coll,1,9);
       PRINT_ELEMENTS(coll) ;

       // check existence of element with value 5
       if (binary_search(coll.begin(), coll.end(), 5)) {
           cout << "5 is present" << endl;
       }
       else {
           cout << "5 is not present" << endl;
       }

       // check existence of element with value 42
       if (binary_search(coll.begin(), coll.end(), 42)) {
           cout << "42 is present" << endl;
       }
       else {
           cout << "42 is not present" << endl;
       }
  }

   1 2 3 4 5 6 7 8 9
   5 is present
   42 is not present

// algo/includes.cpp

    #include "algostuff.hpp"
    using namespace std;

    int main()
    {
        list<int> coll;
        vector<int> search;

        INSERT_ELEMENTS(coll,1,9);
        PRINT_ELEMENTS(coll,"coll: ");

        search.push_back(3);
        search.push_back(4);
        search.push_back(7);
        PRINT_ELEMENTS(search,"search: ");

        // check whether all elements in search are also in coll
        if (includes (coll.begin(), coll.end(),
                      search.begin(), search.end())) {
            cout << "all elements of search are also in coll"
                 << endl;
        }
        else {
            cout << "not all elements of search are also in coll"
                 << endl;
        }
    }

   coll:   1 2 3 4 5 6 7 8 9
   search: 3 4 7
   all elements of search are also in coll

// algo/bounds1.cpp

   #include "algostuff.hpp"
   using namespace std;

   int main()
   {

       list<int> coll;

       INSERT_ELEMENTS(coll,1,9);
       INSERT_ELEMENTS(coll,1,9);
       coll.sort();
       PRINT_ELEMENTS(coll);

       // print first and last position 5 could get inserted
       list<int> :: iterator pos1, pos2;

       pos1 = lower_bound (coll.begin(), coll.end(),
                           5);
       pos2 = upper_bound (coll.begin(), coll.end(),
                           5);

       cout << "5 could get position "
            << distance(coll.begin(),pos1) + 1
            << " up to "
            << distance(coll.begin(),pos2) + 1
            << " without breaking the sorting" << endl;

       // insert 3 at the first possible position without breaking the sorting
       coll.insert (lower_bound(coll.begin(), coll.end(),
                                 3),
                    3);

       // insert 7 at the last possible position without breaking the sorting
       coll.insert (upper_bound(coll.begin(),coll.end(),
                                7),
                    7);

       PRINT_ELEMENTS(coll);
   }

   1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9
   5 could get position 9 up to 11 without breaking the sorting
   1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9

// algo/eqrange1.cpp

   #include "algostuff.hpp"
   using namespace std;

   int main()
   {
       list<int> coll;

       INSERT_ELEMENTS(coll,1,9);
       INSERT_ELEMENTS(coll,1,9);
       coll.sort();
       PRINT_ELEMENTS(coll);

       // print first and last position 5 could get inserted
       pair<list<int>::iterator,list<int>::iterator> range;
       range = equal_range (coll.begin(), coll.end(),
                            5);

       cout << "5 could get position "
            << distance (coll.begin(),range, first) + 1
            << " up to "
            << distance(coll.begin().range.second) + 1
            << " without breaking the sorting" << endl;
   }

   1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9
   5 could get position 9 up to 11 without breaking the sorting

// algo/merge1.cpp

   #include "algostuff.hpp"
   using namespace std;

   int main()
   {
       list<int> coll1;
       set<int> coll2;

       // fill both collections with some sorted elements
       INSERT_ELEMENTS(coll1,1,6);
       INSERT_ELEMENTS(coll2,3,8);

       PRINT_ELEMENTS(coll1,"coll1: ");
       PRINT_ELEMENTS(coll2,"coll2: ");

       // print merged sequence
       cout << "merged: ";
       merge (coll1.begin(), coll1.end(),
              coll2.begin(), coll2.end(),
              ostream_iterator<int>(cout," "));
       cout << endl;
   }

   coll1:  1 2 3 4 5 6
   coll2:  3 4 5 6 7 8
   merged: 1 2 3 3 4 4 5 5 6 6 7 8