From 2697233dcb89e0a9be3655b53521bff5a5dd29d3 Mon Sep 17 00:00:00 2001 From: Antti H S Laaksonen Date: Wed, 17 May 2017 22:42:35 +0300 Subject: [PATCH] Improve language --- chapter03.tex | 68 +++++++++++++++++++++++++-------------------------- 1 file changed, 33 insertions(+), 35 deletions(-) diff --git a/chapter03.tex b/chapter03.tex index c95f29b..3de93a9 100644 --- a/chapter03.tex +++ b/chapter03.tex @@ -299,7 +299,7 @@ For example, in the array \end{tikzpicture} \end{center} the inversions are $(6,3)$, $(6,5)$ and $(9,8)$. -The number of inversions tells us +The number of inversions indicates how much work is needed to sort the array. An array is completely sorted when there are no inversions. @@ -327,22 +327,22 @@ One such algorithm is \key{merge sort}\footnote{According to \cite{knu983}, merge sort was invented by J. von Neumann in 1945.}, which is based on recursion. -Merge sort sorts the subarray \texttt{t}$[a,b]$ as follows: +Merge sort sorts a subarray \texttt{t}$[a \ldots b]$ as follows: \begin{enumerate} \item If $a=b$, do not do anything, because the subarray is already sorted. \item Calculate the position of the middle element: $k=\lfloor (a+b)/2 \rfloor$. -\item Recursively sort the subarray \texttt{t}$[a,k]$. -\item Recursively sort the subarray \texttt{t}$[k+1,b]$. -\item \emph{Merge} the sorted subarrays \texttt{t}$[a,k]$ and \texttt{t}$[k+1,b]$ -into a sorted subarray \texttt{t}$[a,b]$. +\item Recursively sort the subarray \texttt{t}$[a \ldots k]$. +\item Recursively sort the subarray \texttt{t}$[k+1 \ldots b]$. +\item \emph{Merge} the sorted subarrays \texttt{t}$[a \ldots k]$ and \texttt{t}$[k+1 \ldots b]$ +into a sorted subarray \texttt{t}$[a \ldots b]$. \end{enumerate} Merge sort is an efficient algorithm, because it halves the size of the subarray at each step. The recursion consists of $O(\log n)$ levels, and processing each level takes $O(n)$ time. -Merging the subarrays \texttt{t}$[a,k]$ and \texttt{t}$[k+1,b]$ +Merging the subarrays \texttt{t}$[a \ldots k]$ and \texttt{t}$[k+1 \ldots b]$ is possible in linear time, because they are already sorted. For example, consider sorting the following array: @@ -539,7 +539,7 @@ $O(n)$ time assuming that every element in the array is an integer between $0 \ldots c$ and $c=O(n)$. The algorithm creates a \emph{bookkeeping} array, -whose indices are elements in the original array. +whose indices are elements of the original array. The algorithm iterates through the original array and calculates how many times each element appears in the array. @@ -620,7 +620,7 @@ be used as indices in the bookkeeping array. \index{sort@\texttt{sort}} It is almost never a good idea to use -a self-made sorting algorithm +a home-made sorting algorithm in a contest, because there are good implementations available in programming languages. For example, the C++ standard library contains @@ -749,19 +749,19 @@ struct P { It is also possible to give an external \key{comparison function} to the \texttt{sort} function as a callback function. -For example, the following comparison function +For example, the following comparison function \texttt{comp} sorts strings primarily by length and secondarily by alphabetical order: \begin{lstlisting} -bool cmp(string a, string b) { +bool comp(string a, string b) { if (a.size() != b.size()) return a.size() < b.size(); return a < b; } \end{lstlisting} Now a vector of strings can be sorted as follows: \begin{lstlisting} -sort(v.begin(), v.end(), cmp); +sort(v.begin(), v.end(), comp); \end{lstlisting} \section{Binary search} @@ -770,9 +770,9 @@ sort(v.begin(), v.end(), cmp); A general method for searching for an element in an array is to use a \texttt{for} loop -that iterates through the elements in the array. +that iterates through the elements of the array. For example, the following code searches for -an element $x$ in the array \texttt{t}: +an element $x$ in an array \texttt{t}: \begin{lstlisting} for (int i = 0; i < n; i++) { @@ -783,8 +783,8 @@ for (int i = 0; i < n; i++) { \end{lstlisting} The time complexity of this approach is $O(n)$, -because in the worst case, it is needed to check -all elements in the array. +because in the worst case, it is necessary to check +all elements of the array. If the order of the elements is arbitrary, this is also the best possible approach, because there is no additional information available where @@ -801,17 +801,19 @@ in $O(\log n)$ time. \subsubsection{Method 1} -The traditional way to implement binary search +The usual way to implement binary search resembles looking for a word in a dictionary. -At each step, the search halves the active region in the array, -until the target element is found, or it turns out -that there is no such element. +The search maintains an active region in the array, +which initially contains all array elements. +Then, a number of steps is performed, +each of which halves the size of the region. -First, the search checks the middle element of the array. +At each step, the search checks the middle element +of the active region. If the middle element is the target element, the search terminates. Otherwise, the search recursively continues -to the left or right half of the array, +to the left or right half of the region, depending on the value of the middle element. The above idea can be implemented as follows: @@ -827,17 +829,16 @@ while (a <= b) { } \end{lstlisting} -The algorithm maintains a range $a \ldots b$ -that corresponds to the active region of the array. -Initially, the range is $0 \ldots n-1$, the whole array. -The algorithm halves the size of the range at each step, +In this implementation, the active region is $a \ldots b$, +and initially the region is $0 \ldots n-1$. +The algorithm halves the size of the region at each step, so the time complexity is $O(\log n)$. \subsubsection{Method 2} -An alternative method for implementing binary search +An alternative method to implement binary search is based on an efficient way to iterate through -the elements in the array. +the elements of the array. The idea is to make jumps and slow the speed when we get closer to the target element. @@ -860,16 +861,13 @@ if (t[k] == x) { } \end{lstlisting} -The variables $k$ and $b$ contain the position -in the array and the jump length. -If the array contains the element $x$, -the position of $x$ will be in the variable $k$ -after the search. +During the search, the variable $b$ +contains the current jump length. The time complexity of the algorithm is $O(\log n)$, because the code in the \texttt{while} loop is performed at most twice for each jump length. -\subsubsection{C++ implementation} +\subsubsection{C++ functions} The C++ standard library contains the following functions that are based on binary search and work in logarithmic time: @@ -895,7 +893,7 @@ if (k < n && t[k] == x) { } \end{lstlisting} -The following code counts the number of elements +Then, the following code counts the number of elements whose value is $x$: \begin{lstlisting}