# C++. STL. Algorithms processing the sequence as a whole

## Algorithms processing the sequence as a whole without changing the values of the elements (reversing, cyclic shifting, copying, mixing)

### Contents

Search other contents:

##### 1. Algorithm copy. Copies one sequence to another. Example for classes vector, list
The copy algorithm implements copying one sequence to another. A common implementation has the following declaration
template<class InputIterator, class OutputIterator>
OutputIterator copy(
InputIterator first,
InputIterator last,
OutputIterator destBeg);
here
• first, last – input iterators that implement the range of numbers to be copied;
• destBeg – output iterator that specifies the beginning of the range into which the source range is copied.
Example.
#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <iterator>
using namespace std;

void main()
{
// Algorithm copy
// 1. Demo for the vector class
// 1.1. Create initialization list
initializer_list<double> IL1 = { 2.8, 3.5, 1.4, 2.9, 7.3 };

// 1.2. Create a vector instance based on L1 list
vector<double> V1(IL1);

// 1.3. Create a new destination array, the array V1 will be copied into this array
vector<double> V2(V1.size()); // it is necessary to allocate memory in V2

// 1.4. copy V1 => V2, use the copy algorithm
copy(V1.begin(), V1.end(), V2.begin());

// 1.5. Output array V2
cout << "V2 => ";
for (double t : V2)  // foreach style loop
cout << t << "  ";
cout << endl;

// ---------------------------------------
// 2. Demonstration for the list class
// 2.1. Create source array
initializer_list<int> IL2 = { 2, 3, 8, 1, 4, 9 };
list<int> L1(IL2);

// 2.2. Create destination array
list<int> L2(L1.size());

// 2.3. Copy lst2 <= lst1
copy(L1.begin(), L1.end(), L2.begin());

// 2.4. Output lst2 using iterator.
list<int>::iterator it = L2.begin();
cout << "L2 => ";
while (it != L2.end())
{
cout << *it << " ";
it++;
}
cout << endl;
}
Result
V2 => 2.8  3.5  1.4  2.9  7.3
L2 => 2 3 8 1 4 9

### ⇑

##### 2. Algorithm copy_backward. Copies the sequence in reverse order
The copy_backward algorithm copies a sequence from a source range to a destination range in reverse order. The declaration of the algorithm is as follows
template<class BidirectionalIterator1, class BidirectionalIterator2>
BidirectionalIterator2 copy_backward(
BidirectionalIterator1 first,
BidirectionalIterator1 last,
BidirectionalIterator2 destEnd);
here
• first, last – bidirectional iterators indicating the beginning and end of the source range;
• destEnd is a bidirectional iterator pointing to the start of the destination range.
Example.
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
using namespace std;

void main()
{
// copy_backward algorithm - copy data in reverse order.
// Usage for class vector
// 1. Create array based on initialization list
initializer_list<int> IL = { 2, 3, 8, 1, 6 };
vector<int> V(IL);

// 2. Create a new array based on the size of the first one
vector<int> V2(V.size());

// 3. Call the copy_backward algorithm, the data is copied to the V2 vector from the end
copy_backward(V.begin(), V.end(), V2.end());

// 4. Output array V2
vector<int>::iterator it = V2.begin();
while (it != V2.end())
{
cout << *it << " ";
it++;
}
cout << endl;
}
Result
2 3 8 1 6

### ⇑

##### 3. Algorithm reverse. Reverse the order of elements (reversal)
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <time.h>
#include <list>
using namespace std;

int main()
{
// The reverse algorithm - reverse the order of the elements (reversal)
// 1. Create an array of numbers
vector<double> V = { 2.8, 3.3, 4.5, 1.7, 2.9 };

// 2. Reverse the array V - the reverse algorithm.
reverse(V.begin(), V.end());

// 3. Output the reversed array
for (int i = 0; i < V.size(); i++)
cout << V[i] << " ";
cout << endl;
}
Result
2.9 1.7 4.5 3.3 2.8

### ⇑

##### 4. Algorithm reverse_copy. Reverse array to get a copy
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <time.h>
#include <list>
using namespace std;

int main()
{
// The reverse_copy algorithm - reverse the array to get a copy.
// 1. Create an array of numbers
vector<double> V1 = { 1.1, 2.2, 3.3, 4.4, 5.5 }; // array-original
vector<double> V2(V1.size()); // array-copy - set the size of the array (required)

// 2. Reverse array V1 to get a copy of V3 - reverse_copy algorithm
reverse_copy(V1.begin(), V1.end(), V2.begin());

// 3. Output array-original
cout << "V1 => ";
vector<double>::iterator it = V1.begin();
while (it != V1.end())
{
cout << *it << " ";
it++;
}
cout << endl;

// 4. Output the array-copy
cout << "V2 => ";
it = V2.begin();
while (it != V2.end())
{
cout << *it << " ";
it++;
}
}
Result
V1 => 1.1 2.2 3.3 4.4 5.5
V2 => 5.5 4.4 3.3 2.2 1.1

### ⇑

##### 5. Algorithm rotate. Cyclic shift within the specified limits
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main()
{
// Algorithm rotate - cyclic shift to the left within the given limits
// 1. Create an array of numbers
vector<double> V1 = { 1.1, 2.2, 3.3, 4.4, 5.5 }; // array-original

// 2. Set the point to which the offset will occur,
// this point is within V1.begin() to V1.end().
vector<double>::iterator it = V1.begin();

it++; // the next point after V1.begin() is position 2.2

// 3. Shift the entire vector to this point - the rotate algorithm
rotate(V1.begin(), it, V1.end());

// 4. Output the original array
cout << "V1 => ";
it = V1.begin();
while (it != V1.end())
{
cout << *it << " ";
it++;
}
cout << endl;
}
Result
V1 => 2.2 3.3 4.4 5.5 1.1

### ⇑

##### 6. Algorithm rotate_copy. Cyclic shift to obtain a copy of the sequence
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main()
{
// The rotate_copy algorithm - cyclic shift to get a copy of the sequence
// 1. Создать массив чисел
vector<double> V1 = { 1.1, 2.2, 3.3, 4.4, 5.5 }; // array-original
vector<double> V2(V1.size());

// 2. Specify the point to which the offset will occur, this point in the range from V1.begin() to V1.end().
vector<double>::iterator it = V1.begin();
it++;
it++; // set the iterator at position 3.3

// 3. Shift the entire vector to this point - the rotate_copy algorithm
rotate_copy(V1.begin(), it, V1.end(), V2.begin());

// 4. Output the copy array
cout << "V2 => ";
it = V2.begin();
while (it != V2.end())
{
cout << *it << " ";
it++;
}
cout << endl;
}
Result
V2 => 3.3 4.4 5.5 1.1 2.2

### ⇑

##### 7. Algorithm random_shuffle (changed to shuffle). Shuffle sequence randomly
#include <iostream>
#include <queue>
#include <vector>
#include <list>
#include <functional>
#include <algorithm>
using namespace std;

int main()
{
// Algorithm random_shuffle - mixing (reordering) the elements of a sequence
// 1. Using the algorithm without predicate
// 1.1. Declare a vector and form it
vector<float> V1;

for (int i = 0; i < 10; i++)
V1.push_back(i * 1.0f);

// 1.2. Output vector
cout << "V1 => ";
for (float x : V1)
cout << x << "  ";
cout << endl;

// 1.3. Shuffle elements
random_shuffle(V1.begin(), V1.end());

// 1.4. Re-output the vector
cout << "V1 => ";
for (float x : V1)
cout << x << "  ";
cout << endl;
}
Result
V1 => 0  1  2  3  4  5  6  7  8  9
V1 => 8  1  9  2  0  5  7  3  4  6