_STL Algorithms_
by Dan Zigmond


Listing One
template<class InputIterator, class Size}
void size(InputIterator first, InputIterator last, Size& n) 
{
  while (first != last) 
  {
    ++n;
    ++first;
  }
}

Listing Two
(a)
template<class InputIterator, class T>
InputIterator find(InputIterator first, InputIterator last, const T& value);

(b)
template<class InputIterator, class Predicate>
InputIterator find(InputIterator first, InputIterator last, Predicate pred);

(c)
template <class InputIterator, class Predicate>
InputIterator find_if(InputIterator first, InputIterator last, Predicate pred){
    while (first != last && !pred(*first)) ++first;
    return first;
}

(d)
const char* the_line = "This is a line of text.";
char* the_space = 
  find_if(the_line, the_line + strlen(the_line), isspace);

Listing Three
(a)
template<class InputIterator, class T, class Size>
void count(InputIterator first, InputIterator last, const T& value, Size& n);

template<class InputIterator, class Predicate, class Size>
void count_if(InputIterator first,InputIterator last,Predicate pred,Size& n);

(b)
int n = 0;
count_if(the_line, the_line + strlen(the_line), isspace, n);

(c)
count(the_line, the_line + strlen(the_line), ' ', n);

Listing Four
(a)
template<class InputIterator1, class InputIterator2>
bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);

template<class InputIterator1, class InputIterator2, class BinaryPredicate>
bool equal(InputIterator1 first1, InputIterator1 last1, 
           InputIterator2 first2, BinaryPredicate pred);


(b)
template<class InputIterator, class Function>
Function for_each(InputIterator first, InputIterator last, Function f);


(c)
int numbers[10] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
for_each(numbers, numbers+10, sin);

(d)
static unsigned counter = 0;
void print_and_count(int i)
{
  cout << "The number is: " << i << endl;
  ++counter;
}
void main()
{
  int numbers[10] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
  for_each(numbers, numbers+10, print_and_count);
  cout << "The total number of numbers printed is: " << counter;
}

Listing Five
(a)
template<class InputIterator, class OutputIterator>
OutputIterator copy(InputIterator first, InutIterator last, OutputIterator result);

(b) 
template<class InputIterator, class OutputIterator, 
         class UnaryOperation>
OutputIterator transform(InputIterator first, InputIterator last,
                         OutputIterator result, UnaryOperation op);


Listing Six
(a)
int numbers[10] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
transform(numbers, numbers+10, numbers, sin);

(b) 
template<class ForwardIterator, class T>
void replace(ForwardIterator first, ForwardIterator last,
             const T& old_value, const T& new_value);
template<class ForwardIterator, class T>
ForwardIterator remove(ForwardIterator first, ForwardIterator last,
                       const T& value);

(c)
int numbers[5] = {1, 3, 5, 7, 9};
int* end = remove(numbers, numbers+5, 5);



Listing Seven
template<class BidirectionalIterator>
void reverse(BidirectionalIterator first, BidirectionalIterator last)

template<class BidirectionalIterator, class OutputIterator>
void reverse_copy(BidirectionalIterator first, 
                  BidirectionalIterator last, OutputIterator result)

Listing Eight
(a)
template<class ForwardIterator, class T>
void fill(ForwardIterator first, ForwardIterator last, const T& value);

template<class OutputIterator, class Size, class T>
void fill_n(OutputIterator first, Size n, const T& value);

(b)
template <class ForwardIterator, class T>
void fill(ForwardIterator first, ForwardIterator last, const T& value) {
  while (first != last) *first++ = value;
}
template <class OutputIterator, class Size, class T>
void fill_n(OutputIterator first, Size n, const T& value) {
  while (n-- > 0) *first++ = value;
}

Listing Nine
template <class ForwardIterator, class Generator>
void generate(ForwardIterator first, ForwardIterator last, Generator gen);
template <class OutputIterator, class Size, class Generator>
void generate(OutputIterator first, Size n, Generator gen);


Listing Ten
(a)
void main() {
  vector< int > numbers;
  copy(istream_iterator< int >(cin),
       istream_iterator< int >(),
       inserter(numbers, numbers.end()));
  sort(numbers.begin(), numbers.end());
  copy(numbers.begin(), numbers.end(),
       ostream_iterator< int >(cout, ' '));
}

(b)
template<class RandomAccessIterator>
void sort(RandomAccessIterator first, RandomAccessIterator last);

template<class RandomAccessIterator, class Compare>
void sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

(c)
template<class RandomAccessIterator>
void partial_sort(RandomAccessIterator first, RandomAccessIterator middle,

                  RandomAccessIterator last);
template<class RandomAccessIterator, class Compare>
void partial_sort(RandomAccessIterator first, RandomAccessIterator middle,
                  RandomAccessIterator last, Compare comp);

(d)
template<class InputIterator, class RandomAccessIterator>
void partial_sort_copy(InputIterator first, InputIterator last,
          RandomAccessIterator result_first, RandomAccessIterator result_last);
template<class InputIterator, class RandomAccessIterator, class Compare>
void partial_sort_copy(InputIterator first, InputIterator last,
               RandomAccessIterator result_first,
               RandomAccessIterator result_last, Compare comp);

Listing Eleven
(a)
template<class RandomAccessIterator>
void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
                 RandomAccessIterator last);
template<class RandomAccessIterator, class Compare>
void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
                 RandomAccessIterator last, Compare comp);

(b)
template<class T>
const T& min(const T& a, const T& b);

template<class T>
const T& max(const T& a, const T& b);


(c)
template<class InputIterator>
InputIterator min_element(InputIterator first, InputIterator last);

template<class InputIterator, class Compare>
InputIterator min_element(InputIterator first,InputIterator last,Compare comp);

template<class InputIterator>
InputIterator max_element(InputIterator first, InputIterator last);

template<class InputIterator, class Compare>
InputIterator max_element(InputIterator first,InputIterator last,Compare comp);