10.4 – Сортировка массива с помощью сортировки выбором
Сортировка массива – это процесс упорядочивания всех элементов в массиве в определенном порядке. Существует много разных случаев, когда сортировка массива может быть полезна. Например, ваш почтовый клиент обычно отображает электронные письма в порядке времени их получения, поскольку более свежие сообщения обычно считаются более актуальными. Когда вы переходите к списку контактов, имена обычно располагаются в алфавитном порядке, потому что так легче найти имя, которое вы ищете. Оба этих примера включают в себя сортировку данных перед их представлением.
Сортировка массива может сделать поиск в массиве более эффективным не только для людей, но и для компьютеров. Например, рассмотрим случай, когда мы хотим знать, появляется ли имя в списке имен. Чтобы узнать, есть ли имя в списке, нам нужно проверить каждый элемент в массиве. Для массива с большим количеством элементов поиск по всем элементам может быть дорогостоящим.
Однако теперь предположим, что наш массив имен отсортирован по алфавиту. В этом случае нам нужно выполнить поиск только до того момента, когда мы встретим имя, которое в алфавитном порядке больше искомого. На этом этапе, если мы не нашли имя, то мы знаем, что его нет и в остальной части массива, потому что все имена, которые мы не просмотрели в массиве, гарантированно будут в алфавитном порядке больше!
Оказывается, есть даже лучшие алгоритмы поиска в отсортированных массивах. Используя простой алгоритм, мы можем выполнять поиск в отсортированном массиве, содержащем 1000000 элементов, используя всего 20 операций сравнения! Обратной стороной является, конечно, то, что сортировка массива сравнительно дорога, и не стоит часто сортировать массив, чтобы ускорить поиск, если только вы не собираетесь искать в нем много раз.
В некоторых случаях сортировка массива может сделать поиск ненужным. Рассмотрим другой пример, в котором мы хотим найти лучший результат теста. Если массив не отсортирован, мы должны просмотреть каждый элемент в массиве, чтобы найти максимальный результат теста. Если список отсортирован, лучший результат теста будет на первой или последней позиции (в зависимости от того, в каком порядке мы отсортировали, по возрастанию или по убыванию), поэтому нам вообще не нужно искать!
Как работает сортировка
Сортировка обычно выполняется путем многократного сравнения пар элементов массива и их обмена местами, если они соответствуют некоторым предопределенным критериям. Порядок, в котором сравниваются эти элементы, различается в зависимости от используемого алгоритма сортировки. Критерии зависят от того, как будет отсортирован список (например, в порядке возрастания или убывания).
Чтобы поменять местами два элемента, мы можем использовать функцию std::swap() из стандартной библиотеки C++, которая определена в заголовке utility .
Обратите внимание, что после обмена значения x и y поменялись местами!
Сортировка выбором
Существует много способов отсортировать массив. Сортировка выбором, вероятно, является самым простым для понимания алгоритмом, что делает ее хорошим кандидатом для обучения, даже несмотря на то, что это одна из самых медленных сортировок.
Сортировка выбором выполняет следующие шаги для сортировки массива от наименьшего к наибольшему:
- начиная с индекса массива 0, выполнить поиск по всему массиву, чтобы найти наименьшее значение;
- поменять местами наименьшее значение, найденное в массиве, со значением с индексом 0;
- повторите шаги 1 и 2, начиная со следующего индекса.
Другими словами, мы собираемся найти наименьший элемент в массиве и поменять его местами с элементом на первой позиции. Затем мы найдем следующий наименьший элемент и поменяем его местами с элементом на второй позиции. И этот процесс будет повторяться, пока у нас не закончатся элементы.
Вот пример этого алгоритма, работающего на 5 элементах. Начнем с исходного массива:
Сначала находим наименьший элемент, начиная с индекса 0:
Затем мы меняем его местами с элементом с индексом 0:
< 10, 50, 20, 30, 40 >
Теперь, когда первый элемент отсортирован, мы можем игнорировать его. Теперь мы находим наименьший элемент, начиная с индекса 1:
И меняем его местами с элементом с индексом 1:
< 10, 20, 50, 30, 40 >
Теперь мы можем игнорировать первые два элемента. Ищем наименьший элемент, начиная с индекса 2:
И меняем его местами с элементом с индексом 2:
< 10, 20, 30, 50, 40 >
Ищем наименьший элемент, начиная с индекса 3:
И меняем его местами с элементом с индексом 3:
Наконец, ищем наименьший элемент, начиная с индекса 4:
И меняем его местами с элементом с индексом 4 (что ничего не делает):
Обратите внимание, что последнее сравнение всегда будет с самим собой (что является избыточным), поэтому мы можем фактически остановиться на 1 элементе до конца массива.
Сортировка выбором в C++
Вот как этот алгоритм реализован на C++:
Самая запутанная часть этого алгоритма – это цикл внутри другого цикла (вложенный цикл). Внешний цикл ( startIndex ) перебирает каждый элемент один за другим. Для каждой итерации внешнего цикла внутренний цикл ( currentIndex ) используется для поиска наименьшего элемента в оставшейся части массиве (начиная с startIndex + 1). smallestIndex отслеживает индекс наименьшего элемента, найденного внутренним циклом. Затем меняются местами значения элементов с индексами smallestIndex и startIndex . Наконец, внешний цикл ( startIndex ) сдвигается на один элемент, и процесс повторяется.
Подсказка: если у вас возникли проблемы с пониманием того, как работает приведенная выше программа, может быть полезно проработать пример этого случая на листе бумаги. Напишите начальные (несортированные) элементы массива по горизонтали вверху листа. Нарисуйте стрелки, указывающие, на какие элементы указывают индексы startIndex , currentIndex и smallestIndex . Вручную проследите выполнение программы и перерисуйте стрелки по мере изменения индексов. Для каждой итерации внешнего цикла начинайте новую строку, показывающую текущее состояние массива.
Сортировка имен работает по тому же алгоритму. Просто измените тип массива с int на std::string и инициализируйте соответствующими значениями.
std::sort
Поскольку сортировки массивов настолько распространены, стандартная библиотека C++ включает в себя функцию сортировки с именем std::sort . std::sort находится в заголовке <algorithm> и может быть вызвана для массива следующим образом:
По умолчанию std::sort сортирует в порядке возрастания с использованием оператора < для сравнения пар элементов и их обмена местами при необходимости (так же, как в нашем примере сортировки выбором выше).
Подробнее о std::sort мы поговорим в следующей главе.
Небольшой тест
Вопрос 1
Покажите вручную, как работает сортировка выбором для следующего массива: <30, 60, 20, 50, 40, 10>. Покажите состояние массива после каждой перестановки.
Вопрос 2
Перепишите приведенный выше код сортировки выбора для сортировки в порядке убывания (сначала наибольшие числа). Хотя это может показаться сложным, на самом деле это удивительно просто.
Просто измените:
на
smallestIndex , вероятно, также следует переименовать в largeIndex .
Вопрос 3
Это будет непросто, так что примите вызов.
Еще один простой алгоритм сортировки называется «пузырьковой». Пузырьковая сортировка работает, сравнивая соседние пары элементов и меняя их местами, если критерии соблюдены, в итоге элементы «пузыряются» к концу массива. Хотя способов оптимизации пузырьковой сортировки существует немало, в этом тесте мы будем придерживаться неоптимизированной версии, потому что она простейшая.
Неоптимизированная пузырьковая сортировка выполняет следующие шаги для сортировки массива от наименьшего к наибольшему:
- Сравнить элемент 0 с элементом 1. Если элемент 0 больше, поменять его местами с элементом 1.
- Теперь сделать то же самое для элементов 1 и 2, а также для каждой последующей пары элементов, пока не дойдем до конца массива. На этом этапе будет отсортирован последний элемент в массиве.
- Повторять первые два шага снова, пока массив не будет отсортирован полностью.
Напишите код, который отсортирует следующий массив в соответствии с приведенными выше правилами:
И в конце вашей программы распечатайте отсортированные элементы массива.
Подсказка: если мы можем отсортировать по одному элементу за итерацию, это означает, что, чтобы гарантировать сортировку всего массива, нам нужно будет повторять итерации примерно столько раз, сколько чисел в нашем массиве.
Подсказка: сравнивая пары элементов, будьте осторожны с диапазоном вашего массива.
Вопрос 4
Добавьте две оптимизации к алгоритму пузырьковой сортировки, который вы написали в предыдущем вопросе теста:
Алгоритм пузырьковой сортировки одномерного массива на C++
Здравствуй, дорогой гость. В этой статье я расскажу об алгоритме сортировки массива методом пузырька.
Элементы массива, как пузырьки
Алгоритм пузырьковой сортировки — это довольно простой в реализации алгоритм для сортировки массивов. Можно встретить и другие названия: пузырьковая сортировка, Buble sort или сортировка простыми обменами — но все они будут обозночать один и тот же алгоритм. Назван так, потому что большее или меньшее значение «всплывает» (сдвигается) к краю массива после каждой итерации, это будет видно в примере.
Сложность этого алгоритма выражается формулой О(n^2) (n в степени 2). Алгоритм работает медленно с большими массивами, а поэтому малоэффективен и на практике используется редко, чаще всего в учебных целях. Для сортировки массивов на практике используют другие более быстрые алгоритмы, один из них — QuickSort(быстрая сортировка). Функция для быстрой сортировки включена во многие стандартные библиотеки языков программирования, например в языке C функция qsort() из стандартной библиотеки.
Алгоритм работает очень просто. Программа проходит по всем элементами массива по порядку. Каждый текущий элемент сравнивается с соседним и, если он меньше/больше(если сортируем по убыванию/возрастанию соответственно) меняется местами с соседним.
Пример работы алгоритма пузырьковой сортировки
Рассмотрим пример работы алгоритма с массивом, состоящим из четырех элементов.
Имеется массив [4, 5, 2, 6]. Сортировать его будем по убыванию.
N — количество элементов в массиве. i — номер прохода. Алгоритм будет делать проходы по массиву, всего N-1 проходов до N-i ячейки в каждой итерации для любого массива.
Первый проход циклом от первого до N-1 элемента, сравнение условием и перемена местами в случае удовлетворения условия — если левый элемент меньше правого.
4 5 2 6
Сравниваем 4 и 5, 4 меньше 5, а значит мы их меняем местами.
5 4 2 6
Сравниваем 4 и 2, 4 не меньше 2, а значит пропускаем и идем дальше.
5 4 2 6
Сравниваем 2 и 6, 4 меньше 6, а значит мы их меняем местами.
Теперь мы у нас массив [5, 4 ,6, 2]. Как видно, он еще не упорядочен до конца. После первого прохода в конец массива передвинулось самое маленькое значение, теперь нам нужно сделать еще проход до элемента N-2 (ведь идет 2-ая итерация).
Делаем проход, начиная с первого элемента.
5 4 6 2
Сравниваем 5 и 4, 5 не меньше 4, а значит пропускаем и идем дальше.
5 4 6 2
Сравниваем 6 и 4, 6 меньше 4, а значит мы их меняем местами. Мы достигли элемента N-2, завершаем итерацию.
Теперь мы имеем массив [5, 6, 4, 2]. 2 последних элемента упорядочены как нужно. Для завершения нужно выполнить еще один проход до N-3.
5 6 4 2
Сравниваем 5 и 6, 5 меньше 6, а значит мы их меняем местами. Мы достигли элемента N-3, завершаем итерацию.
В итоге на выходе мы получили массив упорядоченный по убыванию — [6, 5, 4, 2].
Реализация алгоритма на языке C++
Программа выполнит последовательно следующие действия:
- Установит размер массива, прося пользователя ввести числовое значение.
- Заполнит массив значениями, введенными пользователем для каждого элемента массива.
- Выведет исходный массив.
- Отсортирует массив по убыванию.
- Выведет отсортированный массив.
Теперь собственно код по каждому из пунктов.
1. Объявим переменную и инициализируем её значение данными, введенными пользователем.
2. Объявим массив из количества элементов, которое ввел пользователь. А то есть объявим массив из n элементов. После запустим цикл и попросим пользователя ввести значение каждого элемента.
3. Выведем значения всех элементов массива, используя цикл.
4. Отсортируем массив по убыванию. Здесь нам понадобятся 2 цикла. Первый будет выполнять количество итераций n-1, как в примере выше, который мы разобрали. Второй цикл будет осуществлять проходы по элементам массива (таких проходов n-i) и сравнивать соседние элементы. Элементы сравниваются условием, если i-ый элемент меньше правого соседа, то они меняются местами, таким образом самый маленький элемент будет в правой крайней части.
5. Выведем отсортированный массив, используя цикл, как в 3-ем действии.
Весь код программы
Обратите внимание, что в коде программы использовались русские символы, если у вас их отображение некорректно, то почитайте статью про решение проблемы с отображением русских символов в консоли.
Написание программы завершено, теперь проверим результаты. А для этого введем в программу массив, сортировку которого мы произвели, рассматривая пример работы алгоритма немного выше в этой статье.
После ввода данных и выполнения программы мы получили результат.
Результат сортировки массива методом пузырька
Как видно на картинке, массив отсортирован по убыванию. Программа работает.
Как я отмечал ранее, алгоритм работает очень медленно с большим объемом данных, а потому непригоден для использования на практике, а пригоден лишь в обучающих и ознакомительных целях. Посмотрите на решения других задач по программированию.
Для вас это может быть интересно:
Алгоритм пузырьковой сортировки одномерного массива на C++ : 21 комментарий
Везде о ней пишут, но по быстродействию она уступает любым другим. Напишите о QuickSort, будет полезно ��
- Nicknixer Автор записи 15.09.2016
Да, действительно, по быстродействию она уступает многим другим. QuickSort в планах есть, в скором будущем.
А как отсортировать массив по возрастанию?
if(mass[r] < mass[r+1])
поменять здесь знак сравнения на противоположный
/*
* Ввести целочисленный массив из N целых чисел.
* Отсортировать этот массив по возрастанию методом пузырька
*/
#include
using namespace std;
int main()
<
int *arr; // указатель для выделения памяти под массив
int size; // размер массива
// Ввод количества элементов массива
cout <> size;
if (size <= 0) <
// Размер масива должен быть положитлеьным
cerr << "Invalid size" << endl;
return 1;
>
arr = new int[size]; // выделение памяти под массив
// заполнение массива
for (int i = 0; i < size; i++) <
cout << "arr[" << i <> arr[i];
>
int temp; // временная переменная для обмена элементов местами
// Сортировка массива пузырьком
for (int i = 0; i < size — 1; i++) <
for (int j = 0; j arr[j + 1]) <
// меняем элементы местами
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
>
>
>
// Вывод отсортированного массива на экран
for (int i = 0; i < size; i++) <
cout << arr[i] << " ";
>
cout << endl;
delete [] arr; // освобождение памяти;
ЭЭЭЭ
а разве можно объявлять int mas[n] .
где n — это int n ??
в C++ статический массив объявляется только константой.
или так: int mas [10] например
или так:
const int n= 5;
int mas[n];
как у Вас это скомпилилось.
- Николай Сергейчук Автор записи 09.02.2017
Можно, главное чтобы n было присвоено значение.
У меня ваша программа не пошла. Пишет ошибки. Делала через Visual Studio
Работает только если в строку int mass вставить конкретное количество элементов
Согласна с Андреем.
Помогите, проверьте правильность строки int mass[n]
То есть в строке int mass[n] присвоить просто любое значение?
Тогда все идет. А почему, не пойму
- Николай Сергейчук Автор записи 27.03.2017
Должно быть присвоено значение для переменной n до объявления массива.
Например:
int n =5;
int mass[n];
пишет что нужна константа в int mass[n];
почему бы во втором цикле не присваивать переменной i2 переменную цикла i, ведь это с каждой итерацией уменьшает количество итераций второго цикла?
for (int i = 0; i < 6; i++) <
for (int i2 = i; i2 m1[i2 + 1])
<
a = m1[i2]; m1[i2] = m1[i2 + 1]; m1[i2 + 1]=a;
>
>
Ошибка в коде, ибо массив нужен динамический.
int n; // Кол-во элементов
cout <> n;
int *mass = new int[n];
Дальше уже можно писать, как на сайте, только в конце добавить delete [] mass;
Грубая ошибка в коде программы, компилятор не создаст массив с переменным размером, здесь нужна куча/динамическая память.
Здравствуйте! Пожалуйста сделайте программу которая сортирует одномерный массив пузырьком по столбцу.В инете никто не сделал это , похоже мало кто знает как вообще сделать.Я надеюсь на вас пожалуйста помогите мне с этим.
Просто в массив нельзя вставить «магическое число». Нужна константа. Либо как сказали выше — динамический массив.
код нифига не работает на с++
Добавить комментарий Отменить ответ
Этот сайт использует Akismet для борьбы со спамом. Узнайте, как обрабатываются ваши данные комментариев.
➕ ➕ 7 способов сортировки массивов на примере С++ с иллюстрациями
Сортировка распределяет элементы в порядке, удобном для работы. Если отсортировать массив чисел в порядке убывания, то первый элемент всегда будет наибольшим, а последний наименьшим. Поэтому желательно хранить информацию упорядочено, чтобы было проще проводить над ней операции.
В данной статье вы научитесь разным техникам сортировок на языке С++. Мы затронем 7 видов:
- Пузырьковая сортировка (Bubble sort);
- Сортировка выбором (Selection sort);
- Сортировка вставками (Insertion sort);
- Быстрая сортировка (Quick sort);
- Сортировка слиянием (Merge sort);
- Сортировка Шелла (Shell sort);
- Сортировка кучей (Heap sort).
Знание этих техник поможет получить работу. На площадке LeetCode содержится более 200 задач , связанных с сортировками. 19 из них входят в топ частых вопросов на собеседованиях по алгоритмам.
1. Пузырьковая сортировка
В пузырьковой сортировке каждый элемент сравнивается со следующим. Если два таких элемента не стоят в нужном порядке, то они меняются между собой местами. В конце каждой итерации (далее называем их проходами) наибольший/наименьший элемент ставится в конец списка.
Прежде чем писать код, разберем сортировку визуально на примере массива из пяти элементов. Отсортируем его в порядке возрастания.
Пузырьковая сортировка
Оранжевым отмечаются элементы, которые нужно поменять местами. Зеленые уже стоят в нужном порядке.
Пузырьковая сортировка
Наибольший элемент — число 48 — оказался в конце списка.
Пузырьковая сортировка
Наибольший элемент уже занимает место в конце массива. Чтобы поставить следующее число по убыванию, можно пройтись лишь до 4-й позиции, а не пятой.
Пузырьковая сортировка
Пузырьковая сортировка
После четвертого прохода получаем отсортированный массив.
Функция сортировки в качестве параметров будет принимать указатель на массив и его размер. Функцией swap() элементы меняются местами друг с другом:
Сложность в лучшем случае: O(n).
Сложность в среднем случае: O(n 2 ).
Сложность в худшем случае: O(n 2 ).
2. Сортировка выбором
Ищем наименьшее значение в массиве и ставим его на позицию, откуда начали проход. Потом двигаемся на следующую позицию.
Возьмем тот же массив из пяти элементов и отсортируем его.
Сортировка выбором
Зеленым отмечается наименьший элемент в подмассиве — он ставится в начало списка.
Число 4 — наименьшее в оставшейся части массива. Перемещаем четверку на вторую позицию после числа 0.
Сортировка выбором
Сортировка выбором
Сортировка выбором
Напишем функцию поиска наименьшего элемента и используем ее в сортировке:
Сложность в любом случае: O(n 2 ).
3. Сортировка вставками
В сортировке вставками начинаем со второго элемента. Проверяем между собой второй элемент с первым и, если надо, меняем местами. Сравниваем следующую пару элементов и проверяем все пары до нее.
Проход №1. Начинаем со второй позиции.
Сортировка вставками
Число 12 больше 5 — элементы меняются местами.
Проход №2. Начинаем с третьей позиции.
Проверяем вторую и третью позиции. Затем первую и вторую.
Сортировка вставками
Проход №3. Начинаем с четвертой позиции.
Сортировка вставками
Произошло три смены местами.
Проход №4. Начинаем с последней позиции.
Сортировка вставками
Получаем отсортированный массив на выходе.
Сложность в лучшем случае: O(n).
Сложность в худшем случае: O(n 2 ).
4. Быстрая сортировка
В основе быстрой сортировки лежит стратегия «разделяй и властвуй». Задача разделяется на более мелкие подзадачи. Подзадачи решаются отдельно, а потом решения объединяют. Точно так же, массив разделяется на подмассивы, которые сортируются и затем сливаются в один.
В первую очередь выбираем опорный элемент. Отметим его синим. Все значения больше опорного элемента ставятся после него, остальные — перед.
Быстрая сортировка
На иллюстрации массив разделяется по опорному элементу. В полученных массивах также выбираем опорный элемент и разделяем по нему.
Опорным может быть любой элемент. Мы выбираем последний в списке.
Чтобы расположить элементы большие — справа от опорного элемента, а меньшие — слева, будем двигаться от начала списка. Если число будет больше опорного, то оно ставится на его место, а сам опорный на место перед ним.
Быстрая сортировка 
Напишем функцию разделения partition() , которая возвращает индекс опорного элемента, и используем ее в сортировке.
Сложность в лучшем случае: O(n*logn).
Сложность в худшем случае: O(n 2 ).
5. Сортировка слиянием
Сортировка слиянием также следует стратегии «разделяй и властвуй». Разделяем исходный массив на два равных подмассива. Повторяем сортировку слиянием для этих двух подмассивов и объединяем обратно.
Быстрая сортировка
Цикл деления повторяется, пока не останется по одному элементу в массиве. Затем объединяем, пока не образуем полный список.
Алгоритм сортировки состоит из четырех этапов:
- Найти середину массива.
- Сортировать массив от начала до середины.
- Сортировать массив от середины до конца.
- Объединить массив.
Для объединения напишем отдельную функцию merge() .
Алгоритм объединения массивов:
- Циклично проходим по двум массивам..
- В объединяемый ставим тот элемент, что меньше.
- Двигаемся дальше, пока не дойдем до конца обоих массивов.
Сложность в любом случае: O(n*logn).
6. Сортировка Шелла
Алгоритм включает в себя сортировку вставками. Исходный массив размером N разбивается на подмассивы с шагом N/2 . Подмассивы сортируются вставками. Затем вновь разбиваются, но уже с шагом равным N/4 . Цикл повторяется. Производим целочисленное деление шага на два каждую итерацию. Когда шаг становится равен 1, массив просто сортируется вставками.
У массива размером с 8, первый шаг будет равен 4.
Сортировка Шелла
Уменьшаем шаг в два раза. Шаг равен 2.
Сортировка Шелла
Сложность в лучшем и среднем случае: O(n*logn).
Сложность в худшем случае: O(n 2 ).
7. Сортировка кучей
Исходный массив представляем в виде структуры данных кучи. Куча – это один из типов бинарного дерева.
У кучи есть следующие свойства:
- Родительский узел всегда больше дочерних;
- На i-ом слое 2 i узлов, начиная с нуля. То есть на нулевом слое 1 узел, на первом – 2 узла, на втором – 4, и т. д. Правило для всех слоев, кроме последнего;
- Слои заполняются слева направо.
После формирования кучи будем извлекать самый старший узел и ставить на конец массива.
Алгоритм сортировки кучей:
- Формируем бинарное дерево из массива.
- Расставляем узлы в дереве так, чтобы получилась куча (метод heapify() ).
- Верхний элемент помещаем в конец массива.
- Возвращаемся на шаг 2, пока куча не опустеет.
Обращаться к дочерним узлам можно, зная, что дочерние элементы i-го элемента находятся на позициях 2*i + 1 (левый узел) и 2*i + 2 (правый узел).
Сортировка кучей
Индекс с нижним левым узлом определим по формуле n/2-1 , где n – длина массива. Получается 5/2 – 1 = 2 – 1 = 1 . С этого индекса и начинаем операцию heapify() . Сравним дочерние узлы 1-й позиции.
Сортировка кучей
Дочерний узел оказался больше. Меняем местами с родителем.
Сортировка кучей
Теперь проверяем родительский узел от позиции 1.
Сортировка кучей
48 больше 3. Меняем местами.
Сортировка кучей
После смены проверяем все дочерние узлы элемента, который опустили. То есть для числа 3 проводим heapify() . Так как 3 меньше 19, меняем местами.
Сортировка кучей
Наибольший элемент оказался наверху кучи. Осталось поставить его в конце массива на позицию 4.
Сортировка кучей
Теперь продолжаем сортировать кучу, но последний элемент игнорируем. Для этого просто будем считать, что длина массива уменьшилась на 1.
Сортировка кучей
Повторяем алгоритм сортировки, пока куча не опустеет, и получаем отсортированный массив.
Сортировка кучей heapify.cpp
Сложность алгоритма в любом случае: O(n*logn).
В этой статье мы познакомились с семью видами сортировок, рассмотрели их выполнение и написание на С++. Попробуйте применить новые знания в решении задачек на LeetCode или Codeforces . Понимание подобных алгоритмов поможет в будущем пройти собеседование.