Algoritmos STL em C++

1. Use o algoritmo std::sort para classificar intervalos de vetores genéricos em C++
2. Use o algoritmo std::reverse para inverter a ordem dos elementos em C++
3. Use o algoritmo std::accumulate para calcular a soma dos elementos em um intervalo em C++
4. Use o algoritmo std::count para contar o número de elementos que satisfazem os critérios específicos em C++

Este artigo irá apresentar várias funções da biblioteca de algoritmos STL em C++.

Use o algoritmo std::sort para classificar intervalos de vetores genéricos em C++

std::sort é um dos algoritmos mais utilizados em STL. Ele tem várias sobrecargas, a mais simples das quais aceita dois iteradores que atendem aos requisitos de LegacyRandomAccessIterator e classifica os elementos em ordem não decrescente. O último é dito porque a ordem dos elementos iguais não tem garantia de ser preservada.

std::sort é comumente usado em intervalos de vector. O trecho de código a seguir demonstra o uso como tal. O algoritmo pode, opcionalmente, assumir a função de comparação, que será usada para avaliar pares de elementos e classificar o intervalo de acordo.

O exemplo a seguir mostra uma linha onde o objeto de função STL - std::greater é passado como a função de comparação. Como alternativa, pode-se definir um objeto de função personalizada ou especificar a expressão lambda diretamente como o terceiro parâmetro de std::sort.

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

template <typename T>
void printRange(std::vector<T> v) {
  for (const auto &item : v) {
    cout << item << ", ";
  }
  cout << endl;
}

int main() {
  std::vector<int> v1 = {1, 3, 5, 11, 9, 10, 13, 20};

  std::sort(v1.begin(), v1.end());
  printRange(v1);

  std::sort(v1.begin(), v1.end(), std::greater<>());
  printRange(v1);

  std::sort(v1.begin(), v1.end(), [](int a, int b) { return (a - 2) != b; });
  printRange(v1);

  return EXIT_SUCCESS;
}

Produção:

1, 3, 5, 9, 10, 11, 13, 20,
20, 13, 11, 10, 9, 5, 3, 1,
1, 3, 5, 9, 10, 11, 13, 20

Use o algoritmo std::reverse para inverter a ordem dos elementos em C++

std::reverse pode ser usado para reverter o conteúdo de recipientes de sequência, como vector, list ou deque. A função aceita dois parâmetros de iterador e pode operar em qualquer tipo genérico. O exemplo de código a seguir mostra dois cenários em que vector de inteiros e list de strings são invertidos. Nós também classificamos o objeto list usando a função membro sort antes de invocar o algoritmo std::reverse. Observe que, o algoritmo std::sort não funciona no contêiner std::list.

#include <algorithm>
#include <iostream>
#include <list>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::list;
using std::string;
using std::vector;

template <typename T>
void printRange(std::vector<T> v) {
  for (const auto &item : v) {
    cout << item << ", ";
  }
  cout << endl;
}

template <typename T>
void printRange(std::list<T> v) {
  for (const auto &item : v) {
    cout << item << ", ";
  }
  cout << endl;
}

int main() {
  std::vector<int> v1 = {1, 3, 5, 11, 9, 10, 13, 20};
  std::list<string> l1 = {"htop", "wtop", "rtop", "ktop", "ktop", "ptop"};

  std::reverse(v1.begin(), v1.end());
  printRange(v1);

  l1.sort();
  std::reverse(l1.begin(), l1.end());
  printRange(l1);

  return EXIT_SUCCESS;
}

Produção:

20, 13, 10, 9, 11, 5, 3, 1,
wtop, rtop, ptop, ktop, ktop, htop,

Use o algoritmo std::accumulate para calcular a soma dos elementos em um intervalo em C++

std::accumulate é parte de algoritmos numéricos que podem ser utilizados para conduzir operações aritméticas comuns em cada elemento de um determinado intervalo. Nesse caso, o algoritmo fornecido calcula a soma total de cada elemento do intervalo. std::acumulate tem duas sobrecargas, a primeira das quais leva os dois iteradores denotando o próprio intervalo e o valor init, que representa o valor inicial para a soma. A segunda sobrecarga pode opcionalmente levar um objeto de função como o quarto parâmetro aplicado em vez de somatório.

#include <algorithm>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

int main() {
  std::vector<int> v1 = {1, 3, 5, 11, 9, 10, 13, 20};

  auto sum = std::accumulate(v1.begin(), v1.end(), 0);
  cout << "Sum of 'v1' vector = " << sum << endl;

  sum = std::accumulate(v1.begin(), v1.end(), 1, std::multiplies());
  cout << "Accumulate of 'v1' vector = " << sum << endl;

  return EXIT_SUCCESS;
}

Produção:

Sum of 'v1' vector = 72
Accumulate of 'v1' vector = 3861000

Use o algoritmo std::count para contar o número de elementos que satisfazem os critérios específicos em C++

A função std::count é um método útil para contar elementos específicos em um determinado intervalo. Ou seja, podemos passar os iteradores de intervalo e o value para corresponder a todos os elementos que são iguais ao valor fornecido. Outra sobrecarga pode aceitar um predicado unário que retorna avaliar as correspondências válidas e o algoritmo recupera o número de contagem de forma correspondente. No próximo exemplo, especificamos uma expressão lambda para contar números pares no objeto vector.

#include <algorithm>
#include <iostream>
#include <list>
#include <numeric>
#include <string>
#include <vector>

using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;

int main() {
  std::vector<int> v1 = {1, 3, 5, 11, 9, 10, 13, 20};

  auto count_10 = std::count(v1.begin(), v1.end(), 10);
  cout << count_10 << " occurrences of number 10" << endl;

  auto count_even =
      std::count_if(v1.begin(), v1.end(), [](int i) { return i % 2 == 0; });
  cout << count_even << " even numbers in 'v1' vector" << endl;

  return EXIT_SUCCESS;
}

Produção:

1 occurrences of number 10
2 even numbers in 'v1' vector