Adjust O(n*logn) formatting.

HappyCerberus · HappyCerberus · commit 0f7d39812a8a · 2023-02-02T11:48:00.000Z
diff --git a/chapters/03_algorithms_03_sorting.tex b/chapters/03_algorithms_03_sorting.tex
@@ -79,12 +79,12 @@ \subsection{\texorpdfstring{\cpp{std::lexicographical_compare_three_way}}{\textt
 \subsection{\texorpdfstring{\cpp{std::sort}}{\texttt{std::sort}}}
 \index{\cpp{std::sort}}
 
-The \cpp{std::sort} algorithm is the canonical $O(n*logn)$ sort (typically implemented as intro-sort).
+The \cpp{std::sort} algorithm is the canonical $O(n\log n)$ sort (typically implemented as intro-sort).
 
 \cppversions{\texttt{sort}}{\CC98}{\CC20}{\CC17}{\CC20}
 \constraints{\cpp{random_access_range}}{\cpp{random_access_range}}{\cpp{operator<}}{\cpp{strict_weak_ordering}}
 
-Due to the $O(n*logn)$ complexity guarantee, \cpp{std::sort} only operates on \cpp{random_access} ranges. Notably, \cpp{std::list} offers a method with an approximate $n*logn$ complexity.
+Due to the $O(n\log n)$ complexity guarantee, \cpp{std::sort} only operates on \cpp{random_access} ranges. Notably, \cpp{std::list} offers a method with an approximate $n\log n$ complexity.
 
 \begin{codebox}[]{\href{https://compiler-explorer.com/z/vef61TWj9}{\ExternalLink}}
 \footnotesize Basic example of using \cpp{std::sort} and \cpp{std::list::sort}.
@@ -110,7 +110,7 @@ \subsection{\texorpdfstring{\cpp{std::stable_sort}}{\texttt{std::stable\_sort}}}
 \cppversions{\texttt{stable\_sort}}{\CC98}{N/A}{\CC17}{\CC20}
 \constraints{\cpp{random_access_range}}{}{\cpp{operator<}}{\cpp{strict_weak_ordering}}
 
-If additional memory is available, stable\_sort remains $O(n*logn)$. However, if it fails to allocate, it will degrade to an $O(n*logn*logn)$ algorithm.
+If additional memory is available, stable\_sort remains $O(n\log n)$. However, if it fails to allocate, it will degrade to an $O(n\log n\log n)$ algorithm.
 
 \begin{codebox}[]{\href{https://compiler-explorer.com/z/TKx8qP8bK}{\ExternalLink}}
 \footnotesize Example of re-sorting a range using \cpp{std::stable_sort}, resulting in a guaranteed order of elements.
diff --git a/chapters/03_algorithms_05_divide.tex b/chapters/03_algorithms_05_divide.tex
@@ -30,7 +30,7 @@ \subsection{\texorpdfstring{\cpp{std::lower_bound}, \cpp{std::upper_bound}}{\tex
 \cppfile{code_examples/algorithms/lower_bound_code.h}
 \end{codebox}
 
-While the algorithms will operate on any \cpp{forward_range}, the logarithmic divide and conquer behaviour is only available for \cpp{random_access_range}. Data structures like \cpp{std::set}, \cpp{std::multiset}, \cpp{std::map} and \cpp{std::multimap} offer their $O(logn)$ implementations of lower and upper bound as methods.
+While the algorithms will operate on any \cpp{forward_range}, the logarithmic divide and conquer behaviour is only available for \cpp{random_access_range}. Data structures like \cpp{std::set}, \cpp{std::multiset}, \cpp{std::map} and \cpp{std::multimap} offer their $O(\log n)$ implementations of lower and upper bound as methods.
 
 \begin{codebox}[]{\href{https://compiler-explorer.com/z/o9Wdvzno9}{\ExternalLink}}
 \footnotesize Example of using \cpp{lower_bound} and \cpp{upper_bound} methods on a \cpp{std::multiset}.
diff --git a/chapters/03_algorithms_15_heap.tex b/chapters/03_algorithms_15_heap.tex
@@ -39,7 +39,7 @@ \subsection{\texorpdfstring{\cpp{std::make_heap}, \cpp{std::push_heap}, \cpp{std
 \subsection{\texorpdfstring{\cpp{std::sort_heap}}{\texttt{std::sort\_heap}}}
 \index{\cpp{std::sort_heap}}
 
-The \cpp{std::sort_heap} will reorder the elements in a heap into a sorted order. Note that this is the same as repeatedly calling \cpp{std::pop_heap}; hence the algorithm has $O(n*logn)$ complexity.
+The \cpp{std::sort_heap} will reorder the elements in a heap into a sorted order. Note that this is the same as repeatedly calling \cpp{std::pop_heap}; hence the algorithm has $O(n\log n)$ complexity.
 
 \cppversions{\texttt{sort\_heap}}{\CC98}{\CC20}{N/A}{\CC20}
 \constraints{\texttt{random\_access\_range}}{}{\texttt{operator<}}{\texttt{strict\_weak\_ordering}}
