# C++ Programming/STL/Algorithms

## Contents

### Algorithms

The STL also provides several useful algorithms, in the form of template functions, that are provided to, with the help of the iterator concept, manipulate the STL containers (or derivations).

The STL algorithms aren't restricted to STL containers, for instance:

```#include <algorithm>

int array[10] = { 2,3,4,5,6,7,1,9,8,0 };

int* begin = &array[0];
int* end = &array[0] + 10;

std::sort(begin, end);// the sort algorithm will work on a C style array
```
The _if suffix
The _copy suffix
• Non-modifying algorithms
• Modifying algorithms
• Removing algorithms
• Mutating algorithms
• Sorting algorithms
• Sorted range algorithms
• Numeric algorithms

#### Permutations

 To do: Complete

#### Sorting and related operations

##### Minimum and maximum

The standard library provides function templates `min` and `max`, which return the minimum and maximum of their two arguments respectively. Each has an overload available that allows you to customize the way the values are compared.

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

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

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

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

An example of how to use the Compare type parameter :

``` #include <iostream>
#include <algorithm>
#include <string>

class Account
{
private :
std::string owner_name;
int credit;
int potential_credit_transfer;

public :
Account(){}
Account(std::string name, int initial_credit, int initial_credit_transfer) :
owner_name(name),
credit(initial_credit),
potential_credit_transfer(initial_credit_transfer)
{}

bool operator<(Account const& account) const { return credit < account.credit; }

int potential_credit() const { return credit + potential_credit_transfer; }

std::string const& owner() const { return owner_name; }
};

struct CompareAccountCredit
{
bool operator()(Account const& account1, Account const& account2) const
{ return account1 < account2; }
};

struct CompareAccountPotentialCredit
{
bool operator()(Account const& account1, Account const& account2) const
{ return account1.potential_credit() < account2.potential_credit(); }
};

int main()
{
Account account1("Dennis Ritchie", 1000, 250), account2("Steeve Jobs", 500, 10000),
result_comparison;

result_comparison = std::min(account1, account2, CompareAccountCredit());
std::cout << "min credit of account is : " + result_comparison.owner() << std::endl;

result_comparison = std::min(account1, account2, CompareAccountPotentialCredit());
std::cout << "min potential credit of account is : " + result_comparison.owner() << std::endl;

return 0;
}
```
 To do: This needs an example of how to use the Compare type parameter