C++,Visual C++,Теорія

C++. STL. Алгоритми що обробляють послідовність в цілому не змінюючи значень елементів

Алгоритми що обробляють послідовність в цілому не змінюючи значень елементів (реверсування, циклічний зсув, копіювання, перемішування)

Зміст

Пошук на інших ресурсах:

1. Алгоритм copy. Копіює одну послідовність в іншу. Приклад для класів vector, list
Алгоритм copy реалізує копіювання однієї послідовності в іншу. Загальнорозповсюджена реалізація має наступне оголошення
template<class InputIterator, class OutputIterator>
OutputIterator copy(
    InputIterator first,
    InputIterator last,
    OutputIterator destBeg);
тут
  • first, last – ітератори вводу, які реалізують діапазон чисел, який потрібно скопіювати;
  • destBeg – ітератор виводу, який визначає початок діапазону, в який копіюється вихідний діапазон.
Приклад.
#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <iterator>
using namespace std;

void main()
{
  // Алгоритм copy
  // 1. Демонстрація для класу vector
  // 1.1. Створити список ініціалізації
  initializer_list<double> IL1 = { 2.8, 3.5, 1.4, 2.9, 7.3 };

  // 1.2. Створити екземпляр vector на основі списку L1
  vector<double> V1(IL1);

  // 1.3. Створити новий масив-приймач, в цей масив буде копіюватись масив V1
  vector<double> V2(V1.size()); // обов'язково потрібно виділити пам'ять у V2

  // 1.4. Скопіювати V1 => V2, використати алгоритм copy
  copy(V1.begin(), V1.end(), V2.begin());

  // 1.5. Вивести масив V2
  cout << "V2 => ";
  for (double t : V2)  // цикл в стилі foreach
    cout << t << "  ";
  cout << endl;

  // ---------------------------------------
  // 2. Демонстрація для класу list
  // 2.1. Створити масив-джерело
  initializer_list<int> IL2 = { 2, 3, 8, 1, 4, 9 };
  list<int> L1(IL2);

  // 2.2. Створити масив-приймач
  list<int> L2(L1.size());

  // 2.3. Скопіювати lst2 <= lst1
  copy(L1.begin(), L1.end(), L2.begin());

  // 2.4. Вивести lst2 з допомогою ітератора
  list<int>::iterator it = L2.begin();
  cout << "L2 => ";
  while (it != L2.end())
  {
    cout << *it << " ";
    it++;
  }
  cout << endl;
}
Результат
V2 => 2.8  3.5  1.4  2.9  7.3
L2 => 2 3 8 1 4 9

  ⇑

2. Алгоритм copy_backward. Копіює послідовність у зворотному порядку
Алгоритм copy_backward виконує копіювання послідовності з вихідного діапазону в діапазон-призначення у зворотньому порядку. Оголошення алгоритму наступне
template<class BidirectionalIterator1, class BidirectionalIterator2>
BidirectionalIterator2 copy_backward(
    BidirectionalIterator1 first,
    BidirectionalIterator1 last,
    BidirectionalIterator2 destEnd);
тут
  • first, last – двонаправлені ітератори, які вказують початок та кінець вихідного діапазону;
  • destEnd – двонаправлений ітератор, який вказує на початок діапазону-призначення.
Приклад.
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
using namespace std;

void main()
{
  // Алгоритм copy_backward - копіювати дані у зворотньому порядку.
  // Використання для класу vector
  // 1. Створити масив на основі списку ініціалізації
  initializer_list<int> IL = { 2, 3, 8, 1, 6 };
  vector<int> V(IL);

  // 2. Створити новий масив на основі розміру першого
  vector<int> V2(V.size());

  // 3. Викликати алгоритм copy_backward,
  //    дані у вектор V2 копіюються з кінця.
  copy_backward(V.begin(), V.end(), V2.end());

  // 4. Вивести масив V2
  vector<int>::iterator it = V2.begin();
  while (it != V2.end())
  {
    cout << *it << " ";
    it++;
  }
  cout << endl;
}
Результат
2 3 8 1 6

  ⇑

3. Алгоритм reverse. Змінити порядок елементів на протилежний (реверсування)
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <time.h>
#include <list>
using namespace std;

int main()
{
  // Алгоритм reverse - змінити порядок елементів на протилежний (реверсування)
  // 1. Створити масив чисел
  vector<double> V = { 2.8, 3.3, 4.5, 1.7, 2.9 };

  // 2. Реверсувати масив V - алгоритм reverse
  reverse(V.begin(), V.end());

  // 3. Вивести реверсований масив
  for (int i = 0; i < V.size(); i++)
    cout << V[i] << " ";
  cout << endl;
}
Результат
2.9 1.7 4.5 3.3 2.8

  ⇑

4. Алгоритм reverse_copy. Реверсувати масив з отриманням копії
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <time.h>
#include <list>
using namespace std;

int main()
{
  // Алгоритм reverse_copy - реверсувати масив з отриманням копії
  // 1. Створити масив чисел
  vector<double> V1 = { 1.1, 2.2, 3.3, 4.4, 5.5 }; // масив-оригінал
  vector<double> V2(V1.size()); // масив-копія - задати розмір масиву (обов'язково)

  // 2. Реверсувати масив V1 з отриманням копії V3 - алгоритм reverse_copy
  reverse_copy(V1.begin(), V1.end(), V2.begin());

  // 3. Вивести масив-оригінал
  cout << "V1 => ";
  vector<double>::iterator it = V1.begin();
  while (it != V1.end())
  {
    cout << *it << " ";
    it++;
  }
  cout << endl;

  // 4. Вивести масив-копію
  cout << "V2 => ";
  it = V2.begin();
  while (it != V2.end())
  {
    cout << *it << " ";
    it++;
  }
}
Результат
V1 => 1.1 2.2 3.3 4.4 5.5
V2 => 5.5 4.4 3.3 2.2 1.1

  ⇑

5. Алгоритм rotate. Циклічний зсув у заданих межах
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main()
{
  // Алгоритм rotate - циклічний зсув вліво в заданих межах
  // 1. Створити масив чисел
  vector<double> V1 = { 1.1, 2.2, 3.3, 4.4, 5.5 }; // масив-оригінал

  // 2. Задати точку, до якої буде відбуватись зсув,
  //    ця точка в межах від V1.begin() до V1.end()
  vector<double>::iterator it = V1.begin();

  it++; // наступна точка після V1.begin() - це є позиція 2.2

  // 3. Здійснити зсув усього вектору до цієї точки - алгоритм rotate
  rotate(V1.begin(), it, V1.end());

  // 4. Вивести масив-оригінал
  cout << "V1 => ";
  it = V1.begin();
  while (it != V1.end())
  {
    cout << *it << " ";
    it++;
  }
  cout << endl;
}
Результат
V1 => 2.2 3.3 4.4 5.5 1.1

  ⇑

6. Алгоритм rotate_copy. Циклічний зсув з отриманням копії послідовності
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main()
{
  // Алгоритм rotate_copy - циклічний зсув з отриманням копії послідовності
  // 1. Створити масив чисел
  vector<double> V1 = { 1.1, 2.2, 3.3, 4.4, 5.5 }; // масив-оригінал
  vector<double> V2(V1.size());

  // 2. Задати точку, до якої буде відбуватись зсув,
  //    ця точка в межах від V1.begin() до V1.end()
  vector<double>::iterator it = V1.begin();
  it++;
  it++; // встановити ітератор на позицію 3.3

  // 3. Здійснити зсув усього вектору до цієї точки - алгоритм rotate_copy
  rotate_copy(V1.begin(), it, V1.end(), V2.begin());

  // 4. Вивести масив-копію
  cout << "V2 => ";
  it = V2.begin();
  while (it != V2.end())
  {
    cout << *it << " ";
    it++;
  }
  cout << endl;
}
Результат
V2 => 3.3 4.4 5.5 1.1 2.2

  ⇑

7. Алгоритм random_shuffle (замінено на shuffle). Перемішати послідовність випадковим чином
#include <iostream>
#include <queue>
#include <vector>
#include <list>
#include <functional>
#include <algorithm>
using namespace std;

int main()
{
  // Алгоритм random_shuffle - перемішування (перевпорядкування) елементів послідовності
  // 1. Використання алгоритму без предикату
  // 1.1. Оголосити вектор та сформувати його
  vector<float> V1;

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

  // 1.2. Вивести вектор
  cout << "V1 => ";
  for (float x : V1)
    cout << x << "  ";
  cout << endl;

  // 1.3. Перемішати елементи
  random_shuffle(V1.begin(), V1.end());

  // 1.4. Повторно вивести вектор
  cout << "V1 => ";
  for (float x : V1)
    cout << x << "  ";
  cout << endl;
}
Результат
V1 => 0  1  2  3  4  5  6  7  8  9
V1 => 8  1  9  2  0  5  7  3  4  6

  ⇑

Споріднені теми

  ⇑