Function main

Exercises/Modules/Chapter 19/Soln19_03/Soln19_03.cpp:46–89

}

int main()
{  
  unsigned count {};
  const auto counting_less{ [&count](int x, int y) { ++count; return x < y; } };
  
  for (auto size : { 500u, 1'000u, 2'000u, 4'000u })
  {
    const auto numbers{ generateRandomNumbers(size) };
    
    count = 0;                 // Reset the count
    auto copy{ numbers };      // Ensure both sorrting algorithms work on exact same random sequence
    quicksort(copy, counting_less);
    const auto quicksort_count{ count };
    
    count = 0;                 // Repeat for bubble sort algorithm
    copy = numbers;
    bubbleSort(copy, counting_less);
    const auto bubble_sort_count{ count };
    
    // Not requested, but it is interesting (see earlier) 
    // to also compare with the sorting algorithm of the C++ Standard Library 
    count = 0;                 // Repeat once more for std::ranges::sort()  (see Chapter 20)
    copy = numbers;
    std::ranges::sort(copy, counting_less);
    const auto std_sort_count{ count };

    const auto quick_sort_theory = static_cast<unsigned>(size * std::log2(size));
    const auto bubble_sort_theory = size * size;
    const auto std_sort_theory = static_cast<unsigned>(size * std::log2(size));

    std::cout 
      << std::format(
          "Number of comparisons for {} elements:\n"
          " - quicksort: {} (n*log(n): {}; ratio: {:.2})\n"
          " - bubble sort: {} (n*n: {}; ratio: {:.2})\n"
          " - Standard Library sort: {} (n*log(n): {}; ratio: {:.2})\n",
          size,
          quicksort_count, quick_sort_theory, static_cast<float>(quick_sort_theory) / quicksort_count,
          bubble_sort_count, bubble_sort_theory, static_cast<float>(bubble_sort_theory) / bubble_sort_count,
          std_sort_count, std_sort_theory, static_cast<float>(std_sort_theory) / std_sort_count
        ) 
     << std::endl;
  }
}