# Algorithm Library | C++ Magicians STL Algorithm

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

 `// 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 before sorting is: 10 20 5 23 42 15
Vector after sorting is: 5 10 15 20 23 42
Vector before reversing 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
```
1. count(first_iterator, last_iterator,x) – To count the occurrences of x in vector.
2. find(first_iterator, last_iterator, x) – Points to last address of vector ((name_of_vector).end()) if element is not present in vector.

 `// 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
```
1. binary_search(first_iterator, last_iterator, x) – Tests whether x exists in sorted vector or not.
2. 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’.
3. 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++ 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.

 `// 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<5; i++) ` `        ``cout << vect[i] << ``" "``; ` ` `  `    ``// sorting to enable use of unique() ` `    ``sort(vect.begin(), vect.end()); ` ` `  `    ``cout << ``"\nVector before removing duplicate "` `             ``" occurrences: "``; ` `    ``for` `(``int` `i=0; i<5; i++) ` `        ``cout << vect[i] << ``" "``; ` ` `  `    ``// Deletes the duplicate occurrences ` `    ``vect.erase(unique(vect.begin(),vect.end()),vect.end()); ` ` `  `    ``cout << ``"\nVector after deleting duplicates: "``; ` `    ``for` `(``int` `i=0; i< vect.size(); i++) ` `        ``cout << vect[i] << ``" "``; ` ` `  `    ``return` `0; ` `}`

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
```
1. next_permutation(first_iterator, last_iterator) – This modified the vector to its next permutation.
2. prev_permutation(first_iterator, last_iterator) – This modified the vector to its previous permutation.

 `// 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 ```
1. 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.

 `// 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 contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks. My Personal Notes arrow_drop_up

Improved By : auspicious_boy, devashish_

Article Tags :
Practice Tags :

110

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.