Uwaga!

Ten artykuł nie jest skończony. Możesz pomóc w jego ukończeniu edytując tą stronę.

Używanie algorytmów

W bibliotece standardowej języka C++ znajdziemy dużo gotowych algorytmów, których możemy użyć do manipulowania wektorami.

Wersja C++

Zalecamy korzystanie z wersji C++20, ponieważ rozwiązania z niej są prostsze. Dla osób, które z jakiegoś powodu nie mogą zainstalować kompilatora, który wspiera najnowszy standard, zamieścimy też przykłady działające na starszej wersji.

Aby móc skorzystać z algorytmów, musimy dodać następujący nagłówek do kodu:

#include <algorithm>

Motywacja

Pokażemy Ci, jak:

1. wyszukać najmniejszą wartość (std::ranges::min())
2. wyszukać największą wartość (std::ranges::max())
3. policzyć ile razy występuje dany element (std::ranges::count())
4. odwrócić kolejność (std::ranges::reverse())
5. posortować elementy wektora (std::ranges::sort())

Algorytmy

Na początek stwórzmy sobie prosty program, na którym bedziemy testować działanie algorytmów. Przygotujmy tablicę liczb:

Tablica liczb

std::vector<int> numbers = { 22, 13, 27, 4 };

W każdym wypadku, użycie algorytmu sprowadzi się do wpisania:

C++20

std::ranges::<nazwa_algorytmu>(<wektor>);

// np.:
std::ranges::sort(numbers);

do C++20

std::<nazwa_algorytmu>(<wektor>.begin(), <wektor>.end());

// np.:
std::sort(numbers.begin(), numbers.end());

przy czym za <wektor> wstawimy przygotowany wyżej numbers. Będziemy po każdej operacji wyświetlać zawartość wektora numbers za pomocą poznanej wcześniej pętli for:

Wyświetlanie elementów tablicy

for (int n : numbers)
	std::cout << n << ' ';

Prezentacja działania

Na początek zobaczmy przykładowy kod, z wykorzystaniem wszystkich tych algorytmów, a później je omówimy.

C++20

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

int main() {
	std::vector<int> numbers = { 22, 13, 27, 4 };

	int min = std::ranges::min(numbers);
	int max = std::ranges::max(numbers);

	std::cout << "Najmniejsza: " << min << '\n';
	std::cout << "Największa: " << max << '\n';

	// Na potrzebę prezentacji funkcji "count"
	// dodaję jedną liczbę 13 na koniec:
	numbers.push_back(13);
	
	size_t count = std::ranges::count(numbers, 13);
	std::cout << "Wystąpień 13: " << count << '\n';

	std::cout << "Przed odwróceniem:\n";
	for (int n : numbers)
		std::cout << n << ' ';

	std::ranges::reverse(numbers);

	std::cout << "\nPo odwróceniu:\n";
	for (int n : numbers)
		std::cout << n << ' ';

	std::cout << "\nPrzed posortowaniem:\n";
	for (int n : numbers)
		std::cout << n << ' ';

	std::ranges::sort(numbers);

	std::cout << "\nPo posortowaniu:\n";
	for (int n : numbers)
		std::cout << n << ' ';
}

Wynik

Najmniejsza: 4
Największa: 27
Wystąpień 13: 2
Przed odwróceniem:
22 13 27 4 13 
Po odwróceniu:
13 4 27 13 22 
Przed posortowaniem:
13 4 27 13 22 
Po posortowaniu:
4 13 13 22 27

do C++20

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

int main() {
	std::vector<int> numbers = { 22, 13, 27, 4 };

	int min = *std::min_element(numbers.begin(), numbers.end()); // 🟡
	int max = *std::max_element(numbers.begin(), numbers.end()); // 🟡

	std::cout << "Najmniejsza: " << min << '\n';
	std::cout << "Największa: " << max << '\n';

	// Na potrzebę prezentacji funkcji "count"
	// dodaję jedną liczbę 13 na koniec:
	numbers.push_back(13);
	
	size_t count = std::count(numbers.begin(), numbers.end(), 13);
	std::cout << "Wystąpień 13: " << count << '\n';

	std::cout << "Przed odwróceniem:\n";
	for (int n : numbers)
		std::cout << n << ' ';

	std::reverse(numbers.begin(), numbers.end());

	std::cout << "\nPo odwróceniu:\n";
	for (int n : numbers)
		std::cout << n << ' ';

	std::cout << "\nPrzed posortowaniem:\n";
	for (int n : numbers)
		std::cout << n << ' ';

	std::sort(numbers.begin(), numbers.end());

	std::cout << "\nPo posortowaniu:\n";
	for (int n : numbers)
		std::cout << n << ' ';
}

Wynik

Najmniejsza: 4
Największa: 27
Wystąpień 13: 2
Przed odwróceniem:
22 13 27 4 13 
Po odwróceniu:
13 4 27 13 22 
Przed posortowaniem:
13 4 27 13 22 
Po posortowaniu:
4 13 13 22 27

Uwaga

Zapis, który oznaczyłem znakiem 🟡, jest bardziej skomplikowany i niestety w wersjach przed C++20 nie innej, prostszej możliwości. Jeśli korzystasz ze starszej wersji C++, rozważ zainstalowanie kompilatora, który wspiera najnowszy standard języka.

Omówienie

Najmniejsza wartość

Aby znaleźć najmniejszą wartość wewnątrz wektora, używamy std::ranges::min:

C++20

std::cout << std::ranges::min(numbers);

do C++20

std::cout << std::min(numbers.begin(), numbers.end());

Największa wartość

Aby znaleźć największą wartość wewnątrz wektora, używamy std::ranges::max tak:

C++20

std::cout << std::ranges::max(numbers);

do C++20

std::cout << std::max(numbers.begin(), numbers.end());

Zliczanie wystąpień

Uwaga

Na potrzeby tego algorytmu, dodamy sobie jeszcze jedną wartość 13 na koniec tablicy.

count służy do zliczania wystąpień elementów, w tym wypadku, wewnątrz wektora. Korzystamy z tego w ten sposób:

C++20

std::cout << std::ranges::count(numbers, 13);

do C++20

std::cout << std::count(numbers.begin(), numbers.end(), 13);

Możemy również zapisać ten wynik do zmiennej. Powinniśmy do tego użyć specjalnego typu size_t, który w uproszczeniu jest nieujemną liczbą (ponieważ liczba wystąpień nie może być ujemna):

C++20

std::size_t count = std::ranges::count(numbers, 13);
std::cout << "Liczba wystąpień 13: " << count;

do C++20

std::size_t count = std::count(numbers.begin(), numbers.end(), 13);
std::cout << "Liczba wystąpień 13: " << count;

Odwracanie kolejności

Aby odwrócić kolejność elementów wektora, używamy std::ranges::reverse  (lub std::reverse przed C++20).

C++20

std::ranges::reverse(numbers);

do C++20

std::reverse(numbers.begin(), numbers.end());

Sortowanie

Używamy funkcji sortującej w ten sposób:

C++20

std::ranges::sort(numbers);

do C++20

std::sort(numbers.begin(), numbers.end());