# Algorithm Library | C++ Magicians STL Algorithm

• Difficulty Level : Medium
• Last Updated : 11 Aug, 2021

For all those who aspire to excel in competitive programming, only having a knowledge about containers of STL is of less use till one is not aware what all STL has to offer.
STL has an ocean of algorithms, for all < algorithm > library functions : Refer here.
Some of the most used algorithms on vectors and most useful one’s in Competitive Programming are mentioned as follows :

Non-Manipulating Algorithms

1. sort(first_iterator, last_iterator) – To sort the given vector.
2. reverse(first_iterator, last_iterator) – To reverse a vector.
3. *max_element (first_iterator, last_iterator) – To find the maximum element of a vector.
4. *min_element (first_iterator, last_iterator) – To find the minimum element of a vector.
5. accumulate(first_iterator, last_iterator, initial value of sum) – Does the summation of vector elements

## CPP

 `// A C++ program to demonstrate working of sort(),``// reverse()``#include ``#include ``#include ``#include //For accumulate operation``using` `namespace` `std;` `int` `main()``{``    ``// Initializing vector with array values``    ``int` `arr[] = {10, 20, 5, 23 ,42 , 15};``    ``int` `n = ``sizeof``(arr)/``sizeof``(arr);``    ``vector<``int``> vect(arr, arr+n);` `    ``cout << ``"Vector is: "``;``    ``for` `(``int` `i=0; i
Output
```Vector is: 10 20 5 23 42 15
Vector after sorting is: 5 10 15 20 23 42
Vector after reversing is: 42 23 20 15 10 5
Maximum element of vector is: 42
Minimum element of vector is: 5
The summation of vector elements is: 115```

6.count(first_iterator, last_iterator,x) – To count the occurrences of x in vector.

7. find(first_iterator, last_iterator, x) – Returns an iterator to the first occurence of x in vector and points to last address of vector ((name_of_vector).end()) if element is not present in vector.

## CPP

 `// C++ program to demonstrate working of count()``// and find()``#include ``#include ``#include ``using` `namespace` `std;` `int` `main()``{``    ``// Initializing vector with array values``    ``int` `arr[] = {10, 20, 5, 23 ,42, 20, 15};``    ``int` `n = ``sizeof``(arr)/``sizeof``(arr);``    ``vector<``int``> vect(arr, arr+n);` `    ``cout << ``"Occurrences of 20 in vector : "``;` `    ``// Counts the occurrences of 20 from 1st to``    ``// last element``    ``cout << count(vect.begin(), vect.end(), 20);` `    ``// find() returns iterator to last address if``    ``// element not present``    ``find(vect.begin(), vect.end(),5) != vect.end()?``                         ``cout << ``"\nElement found"``:``                     ``cout << ``"\nElement not found"``;` `    ``return` `0;``}`
Output
```Occurrences of 20 in vector : 2
Element found```

8. binary_search(first_iterator, last_iterator, x) – Tests whether x exists in sorted vector or not.

9. lower_bound(first_iterator, last_iterator, x) – returns an iterator pointing to the first element in the range [first,last) which         has a value not less than ‘x’.

10. upper_bound(first_iterator, last_iterator, x) – returns an iterator pointing to the first element in the range [first,last)                  which has a value greater than ‘x’.

## C++

 `// C++ program to demonstrate working of lower_bound()``// and upper_bound().``#include ``#include ``#include ``using` `namespace` `std;` `int` `main()``{``    ``// Initializing vector with array values``    ``int` `arr[] = {5, 10, 15, 20, 20, 23, 42, 45};``    ``int` `n = ``sizeof``(arr)/``sizeof``(arr);``    ``vector<``int``> vect(arr, arr+n);` `    ``// Sort the array to make sure that lower_bound()``    ``// and upper_bound() work.``    ``sort(vect.begin(), vect.end());` `    ``// Returns the first occurrence of 20``    ``auto` `q = lower_bound(vect.begin(), vect.end(), 20);` `    ``// Returns the last occurrence of 20``    ``auto` `p = upper_bound(vect.begin(), vect.end(), 20);` `    ``cout << ``"The lower bound is at position: "``;``    ``cout << q-vect.begin() << endl;` `    ``cout << ``"The upper bound is at position: "``;``    ``cout << p-vect.begin() << endl;` `    ``return` `0;``}`
Output
```The lower bound is at position: 3
The upper bound is at position: 5```

Some Manipulating Algorithms

1. arr.erase(position to be deleted) – This erases selected element in vector and shifts and resizes the vector elements accordingly.
2. arr.erase(unique(arr.begin(),arr.end()),arr.end()) – This erases the duplicate occurrences in sorted vector in a single line.

## CPP

 `// C++ program to demonstrate working of erase()``#include ``#include ``#include ``using` `namespace` `std;` `int` `main()``{``    ``// Initializing vector with array values``    ``int` `arr[] = {5, 10, 15, 20, 20, 23, 42, 45};``    ``int` `n = ``sizeof``(arr)/``sizeof``(arr);``    ``vector<``int``> vect(arr, arr+n);` `    ``cout << ``"Vector is :"``;``    ``for` `(``int` `i=0; i<6; i++)``        ``cout << vect[i]<<``" "``;` `    ``// Delete second element of vector``    ``vect.erase(vect.begin()+1);` `    ``cout << ``"\nVector after erasing the element: "``;``    ``for` `(``int` `i=0; i
Output
```Vector is :5 10 15 20 20 23
Vector after erasing the element: 5 15 20 20 23
Vector before removing duplicate  occurrences: 5 15 20 20 23
Vector after deleting duplicates: 5 15 20 23 42 45 ```

3. next_permutation(first_iterator, last_iterator) – This modified the vector to its next permutation.

4. prev_permutation(first_iterator, last_iterator) – This modified the vector to its previous permutation.

## CPP

 `// C++ program to demonstrate working``// of next_permutation()``// and prev_permutation()``#include ``#include ``#include ``using` `namespace` `std;` `int` `main()``{``    ``// Initializing vector with array values``    ``int` `arr[] = {5, 10, 15, 20, 20, 23, 42, 45};``    ``int` `n = ``sizeof``(arr)/``sizeof``(arr);``    ``vector<``int``> vect(arr, arr+n);` `    ``cout << ``"Given Vector is:\n"``;``    ``for` `(``int` `i=0; i
Output
```Given Vector is:
5 10 15 20 20 23 42 45
Vector after performing next permutation:
5 10 15 20 20 23 45 42
Vector after performing prev permutation:
5 10 15 20 20 23 42 45 ```

5. distance(first_iterator,desired_position) – It returns the distance of desired position from the first iterator.This function               is very useful while finding the index.

## CPP

 `// C++ program to demonstrate working of distance()``#include ``#include ``#include ``using` `namespace` `std;` `int` `main()``{``    ``// Initializing vector with array values``    ``int` `arr[] = {5, 10, 15, 20, 20, 23, 42, 45};``    ``int` `n = ``sizeof``(arr)/``sizeof``(arr);``    ``vector<``int``> vect(arr, arr+n);` `    ``// Return distance of first to maximum element``    ``cout << ``"Distance between first to max element: "``;``    ``cout << distance(vect.begin(),``                     ``max_element(vect.begin(), vect.end()));``    ``return` `0;``}`
Output
`Distance between first to max element: 7`

More – STL Articles
This article is contributed by Manjeet Singh. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.