Sorting in C++

luku03.tex

@@ -618,85 +618,77 @@ but it can only be used when the constant $c$
 is so small that the array elements can
 be used as indices in the bookkeeping array.
 
-\section{Järjestäminen C++:ssa}
+\section{Sorting in C++}
 
 \index{sort@\texttt{sort}}
 
-Järjestämisalgoritmia
+It is almost never a good idea to use
-ei yleensä koskaan kannata koodata itse,
+an own implementation of a sorting algorithm
-vaan on parempi ratkaisu käyttää
+in a contest, because there are good
-ohjelmointikielen valmista toteutusta.
+implementations available in programming languages.
-Esimerkiksi
+For example, the C++ standard library contains
-C++:n standardikirjastossa on funktio \texttt{sort},
+the function \texttt{sort} that can be easily used for
-jonka avulla voi järjestää helposti taulukoita
+sorting arrays and other data structures.
-ja muita tietorakenteita.
 
-Valmiin toteutuksen käyttämisessä on monia etuja.
+There are many benefits in using a library function.
-Ensinnäkin se säästää aikaa, koska järjestämisalgoritmia
+First, it saves time because there is no need to
-ei tarvitse kirjoittaa itse.
+implement the function.
-Lisäksi valmis toteutus on varmasti tehokas ja toimiva:
+In addition, the library implementation is
-vaikka järjestämisalgoritmin toteuttaisi itse,
+certainly correct and efficient: it is not probable
-siitä tulisi tuskin valmista toteutusta parempi.
+that a home-made sorting function would be better.
 
-Tutustumme seuraavaksi C++:n \texttt{sort}-funktion
+In this section we will see how to use the
-käyttämiseen.
+C++ \texttt{sort} function.
-Seuraava koodi järjestää vektorin \texttt{v}
+The following code sorts the numbers
-luvut pienimmästä suurimpaan:
+in vector \texttt{t} in increasing order:
 \begin{lstlisting}
 vector<int> v = {4,2,5,3,5,8,3};
 sort(v.begin(),v.end());
 \end{lstlisting}
-Järjestämisen seurauksena
+After the sorting, the contents of the
-vektorin sisällöksi tulee
+vector will be
-$\{2,3,3,4,5,5,8\}$.
+$[2,3,3,4,5,5,8]$.
-Oletuksena \texttt{sort}-funktio järjestää
+The default sorting order in increasing,
-siis alkiot pienimmästä suurimpaan,
+but a reverse order is possible as follows:
-mutta järjestyksen saa käänteiseksi näin:
 \begin{lstlisting}
 sort(v.rbegin(),v.rend());
 \end{lstlisting}
-Tavallisen taulukon voi järjestää seuraavasti:
+A regular array can be sorted as follows:
 \begin{lstlisting}
-int n = 7; // taulukon koko
+int n = 7; // array size
 int t[] = {4,2,5,3,5,8,3};
 sort(t,t+n);
 \end{lstlisting}
-Seuraava koodi taas järjestää merkkijonon \texttt{s}:
+The following code sorts the string \texttt{s}:
 \begin{lstlisting}
-string s = "apina";
+string s = "monkey";
 sort(s.begin(), s.end());
 \end{lstlisting}
-Merkkijonon järjestäminen tarkoittaa,
+Sorting a string means that the characters
-että sen merkit järjestetään aakkosjärjestykseen.
+in the string are sorted.
-Esimerkiksi merkkijono ''apina''
+For example, the string ''monkey'' becomes ''ekmnoy''.
-on järjestettynä ''aainp''.
 
-\subsubsection{Vertailuoperaattori}
+\subsubsection{Comparison operator}
 
-\index{vertailuoperaattori@vertailuoperaattori}
+\index{comparison operator}
 
-Funktion \texttt{sort} käyttäminen vaatii,
+The function \texttt{sort} requires that
-että järjestettävien alkioiden
+a \key{comparison operator} is defined for the data type
-tietotyypille on määritelty \key{vertailuoperaattori} \texttt{<},
+of the elements to be sorted.
-jonka avulla voi selvittää, mikä on kahden alkion järjestys.
+During the sorting, this operator will be used
-Järjestämisen aikana \texttt{sort}-funktio
+whenever it is needed to find out the order of two elements.
-käyttää operaattoria \texttt{<} aina, kun sen täytyy
-vertailla järjestettäviä alkioita.
 
-Vertailuoperaattori on määritelty valmiiksi
+Most C++ data types have a built-in comparison operator
-useimmille C++:n tietotyypeille,
+and elements of those types can be sorted automatically.
-minkä ansiosta niitä pystyy järjestämään automaattisesti.
+For example, numbers are sorted according to their values
-Jos järjestettävänä on lukuja, ne järjestyvät
+and strings are sorted according to alphabetical order.
-suuruusjärjestykseen,
-ja jos järjestettävänä on merkkijonoja,
-ne järjestyvät aakkosjärjestykseen.
 
 \index{pair@\texttt{pair}}
 
-Parit (\texttt{pair}) järjestyvät ensisijaisesti
+Pairs (\texttt{pair}) are sorted primarily by the first
-ensimmäisen kentän (\texttt{first}) mukaan.
+element (\texttt{first}).
-Jos kuitenkin parien ensimmäiset kentät ovat samat,
+However, if the first elements of two pairs are equal,
-järjestys määräytyy toisen kentän (\texttt{second}) mukaan:
+they are sorted by the second element (\texttt{second}):
 \begin{lstlisting}
 vector<pair<int,int>> v;
 v.push_back({1,5});
@@ -704,13 +696,14 @@ v.push_back({2,3});
 v.push_back({1,2});
 sort(v.begin(), v.end());
 \end{lstlisting}
-Tämän seurauksena parien järjestys on
+After this, the order of the pairs is
-$(1,2)$, $(1,5)$ ja $(2,3)$.
+$(1,2)$, $(1,5)$ and $(2,3)$.
 
 \index{tuple@\texttt{tuple}}
-Vastaavasti \texttt{tuple}-rakenteet
+
-järjestyvät ensisijaisesti ensimmäisen kentän,
+Correspondingly, tuples (\texttt{tuple})
-toissijaisesti toisen kentän, jne., mukaan:
+are sorted primarily by the first element,
+secondarily by the second element, etc.:
 \begin{lstlisting}
 vector<tuple<int,int,int>> v;
 v.push_back(make_tuple(2,1,4));
@@ -718,25 +711,26 @@ v.push_back(make_tuple(1,5,3));
 v.push_back(make_tuple(2,1,3));
 sort(v.begin(), v.end());
 \end{lstlisting}
-Tämän seurauksena järjestys on
+After this, the order of the tuples is
-$(1,5,3)$, $(2,1,3)$ ja $(2,1,4)$.
+$(1,5,3)$, $(2,1,3)$ and $(2,1,4)$.
 
-\subsubsection{Omat tietueet}
+\subsubsection{User-defined structs}
 
-Jos järjestettävänä on omia tietueita,
+User-defined structs do not have a comparison
-niiden vertailuoperaattori täytyy toteuttaa itse.
+operator automatically.
-Operaattori määritellään tietueen sisään
+The operator should be defined inside
-\texttt{operator<}-nimisenä funktiona,
+the struct as a function
-jonka parametrina on toinen alkio.
+\texttt{operator<}
-Operaattorin tulee palauttaa \texttt{true},
+whose parameter is another element of the same type.
-jos oma alkio on pienempi kuin parametrialkio,
+The operator should return \texttt{true}
-ja muuten \texttt{false}.
+if the element is smaller than the parameter,
+and \texttt{false} otherwise.
 
-Esimerkiksi seuraava tietue \texttt{P}
+For example, the following struct \texttt{P}
-sisältää pisteen x- ja y-koordinaatit.
+contains the x and y coordinate of a point.
-Vertailuoperaattori on toteutettu niin,
+The comparison operator is defined so that
-että pisteet järjestyvät ensisijaisesti x-koor\-di\-naa\-tin
+the points are sorted primarily by the x coordinate
-ja toissijaisesti y-koordinaatin mukaan.
+and secondarily by the y coordinate.
 
 \begin{lstlisting}
 struct P {
@@ -748,15 +742,16 @@ struct P {
 };
 \end{lstlisting}
 
-\subsubsection{Vertailufunktio}
+\subsubsection{Comparison function}
 
-\index{vertailufunktio@vertailufunktio}
+\index{comparison function}
 
-On myös mahdollista antaa
+It is also possible to give an external
-\texttt{sort}-funktiolle ulkopuolinen \key{vertailufunktio}.
+\key{comparison function} to the \texttt{sort} function
-Esimerkiksi seuraava vertailufunktio
+as a callback function.
-järjestää merkkijonot ensisijaisesti pituuden mukaan
+For example, the following comparison function
-ja toissijaisesti aakkosjärjestyksen mukaan:
+sorts strings primarily by length and secondarily
+by alphabetical order:
 
 \begin{lstlisting}
 bool cmp(string a, string b) {
@@ -764,14 +759,14 @@ bool cmp(string a, string b) {
     return a < b;
 }
 \end{lstlisting}
-Tämän jälkeen merkkijonovektorin voi järjestää näin:
+Now a vector of strings can be sorted as follows:
 \begin{lstlisting}
 sort(v.begin(), v.end(), cmp);
 \end{lstlisting}
 
-\section{Binäärihaku}
+\section{Binary search}
 
-\index{binxxrihaku@binäärihaku}
+\index{binary search}
 
 Tavallinen tapa etsiä alkiota taulukosta
 on käyttää \texttt{for}-silmukkaa, joka käy läpi