Почему компаратор с <= может сломать std::sort?

При сортировке чисел по возрастанию хочется написать сравнение так:

std::sort(values.begin(), values.end(),
          [](int a, int b) { return a <= b; });

Проблема проявляется, когда в диапазоне есть одинаковые значения. Для двух равных чисел компаратор возвращает true, хотя ни одно из них не должно стоять раньше другого.

Проверим самую простую ситуацию:

auto lessOrEqual = [](int a, int b) { return a <= b; };
std::cout << lessOrEqual(5, 5);

Результат равен 1. Но std::sort требует строгий слабый порядок, элемент не может быть меньше самого себя. Использование такого компаратора нарушает требования алгоритма.

Правильный вариант для возрастания использует строгое сравнение:

std::sort(values.begin(), values.end(),
          [](int a, int b) { return a < b; });

Если у объектов несколько полей, добавь запасной критерий. Например, при одинаковом приоритете можно сравнить id:

if (a.priority != b.priority) return a.priority < b.priority;
return a.id < b.id;

Так порядок будет предсказуемым и для равных приоритетов. Если же требуется сохранить исходный порядок равных элементов, используй std::stable_sort с корректным строгим компаратором, а не заменяй < на <=.

📣 C++ Ready | #совет

Gemini Pro на 24 месяца за 800₽!

Вместо 39.000₽ — всего 800₽ ($9.9) за 2 года. По акции сейчас это 33₽ в месяц, в 48 раз выгоднее!

➡Argon 4.0 + Claude Opus 5.5 — для кода
➡Nano Banana 2 Pro — для картинок
➡Генерация видео — ролики и анимации
➡AntiGravity + 5 ТБ облака
➡Opus 5.5 и Sonnet 5.5
➡Youtube Premium

Акция ограничена по времени, дальше будет официальная цена 480$!

Приобрести можно в Магазине с 20.000+ покупок и 2000+ отзывов (есть возвраты и замены).

Объединяем две хронологии событий без повторной сортировки!

Представим, что приложение получило события из двух источников. Каждый источник уже отсортировал свои записи по времени. Чтобы получить общую хронологию, не нужно складывать всё вместе и сортировать заново, два упорядоченных диапазона можно слить.

Опишем событие и подготовим два входных списка. Внутри каждого время должно идти по возрастанию:

struct Event {
    int time;
    std::string message;
};

std::vector<Event> app = {{10, "start"}, {30, "save"}};
std::vector<Event> worker = {{20, "job"}, {40, "done"}};

Заранее выделим место под все записи. Это не меняет размер вектора, но избавляет его от лишнего расширения при добавлении элементов:

std::vector<Event> timeline;
timeline.reserve(app.size() + worker.size());

Теперь используем std::ranges::merge. Проекции сообщают алгоритму, что сравнивать нужно поле time, а не весь объект:

std::ranges::merge(app, worker, std::back_inserter(timeline),
                   {}, &Event::time, &Event::time);

Результат будет идти в порядке 10, 20, 30, 40. Если времена совпадут, алгоритм сохранит порядок элементов внутри каждого исходного списка. Записи с одинаковым временем не исчезают, merge переносит их все.

Проверим результат обычным обходом:

for (const Event& event : timeline) {
    std::cout << event.time << " " << event.message << '\n';
}

Слияние работает за время, пропорциональное сумме длин списков, и удобно для логов, событий и результатов нескольких запросов.

📣 C++ Ready | #практика