\section{Ordena\c c\~ao por troca}
M\ee todos de ordena\cao\ por troca repetem a troca pares de elementos
que se encontram fora de ordem at\ee\ obter a ordem total da \sqn. O 
mais not\aa vel desses algoritmos \ee\ o \quicksort, cujo algoritmo
espelha a constru\cao\ de uma \aa rvore bin\aa ria para os elementos da
\sqn\ em quest\ao:
\begin{itemize}
	\item escolha arbitr\aa ria de um \emph{piv\^o}
		para a raiz da \aa rvore;
	\item particionamento do conjunto restante em elementos menores ou
		iguais ao piv\^o e elementos maiores ou iguais ao piv\^o;
	\item repeti\cao\ do processo para ordena\cao\ de cada uma das
		parti\coes.
\end{itemize}

\'E um algoritmo t\ii pico do paradigma \emph{dividir para conquistar}: para
resolver um problema (no caso, ordenar uma \sqn) divida-o em subproblemas
e resolva-os pelo mesmo  processo
(a ordena\cao\ das parti\coes). Finalmente,  combine as solu\coes\ parciais:
no caso concatenar as sub\sqn s ordenadas. 
A \rffig{quick:haskell} apresenta um algoritmo de \quicksort\ escrito em 
Haskell.

\begin{figure}
          \lstinputlisting[language=Haskell]{quick.hs}
          \caption{Algoritmo \quicksort}\label{quick:haskell}
\end{figure}

Note que a fun\cao\ \emph{partition} particiona uma \sqn\ dada em  tr\^es
sub\sqn s: de elementos  menores, iguais e maiores que o \pivot,
respectivamente. Note ainda que o \pivot\ \ee\ sempre o primeiro elemento da
\sqn\ a ordenar.

O algoritmo em Haskell \ee\ simples e est\aa\ expresso em 15 linhas. Se a
fun\cao\ \emph{parttion} da biblioteca \emph{Lists} tivesse sido usada
esse algoritmo poderia ter uma cinco linhas. No entanto, ele exibe ao menos uma
caracter\ii s tica desagrad\aa vel: cada chamada recursiva demanda cria\cao\ de
tr\^es novas \sqn s.

\begin{ex}
	Prove que para ordenar uma \sqn\ de $m$ elementos esse algoritmo pode 
	demandar a cria\cao\ $O(m^2)$ listas.
\end{ex}

\begin{ex}
	Prove que os algoritmo \inssort, \selsort e \heapsort, anteriormente
	apresentados usam espa\co\ $O(1)$ al\ee m do espa\co\ do vetor inicial.
\end{ex}


Para evitar a constru\cao\ de novas listas a cada particionamento, a solu\cao\
\ee\ reorganizar a pr\oo pria \sqn\ de entrada que dever\aa\ estar representada
em um vetor. O algoritmo de particioanemto de Lomut\footnote{
Apresentado nas aulas de aula sobre \emph{``Corre\cao de Programas.''}}
particiona uma \sqn\ dada, usandp o elemento inicial como \pivot\ em duas
\sqn\ de elementos menores ou iguas e maiores ou iguais ao \pivot,
respectivamente. 

\begin{ex}
	Prove que o algoritmo de Lomut demanda $O(m)$ opera\coes, o que
	inclui compara\coes de chaves, movimentos, transi\coes\ e quaiquer
	outras opera\coes\ durante o processo de ordena\cao.
\end{ex}



Podemos entender a oordena\cao\ via \quicksort\
como a realiza\cao\ de tarefas orientada por uma agenda:
\begin{itemize}
	\item cada tarefa na agenda indica uma parti\cao\ (se\cao\ do vetor 
		dado) a ordenar;
	\item parti\coes\ (se\coes\ do vetor)  
		ausentes da agenda est\ao\ ordenadas.
\end{itemize}

Nesse contexto, cada tarefa na agenda poderia ser representada por um par 
definindo os
limites inferior e superior da se\cao\ a ordenar. A genda em si poderia ser
uma \sqn, representada como uma fila ou um stack, por exemplo. Se representada
como um stack, ela poderia estar armazenada no pr\oo prio stack do programa,
o que implica em codificar o \quicksort\ como algoritmo recursivo, que
\ee\ alternativa usada  \cite{cormen:lrs:algo}, cap\ii tulo 7, 
\cite{bentley:pearls}, coluna 11, e
\cite{bentley-sedgewick:ternary}. 
A coluna 11 de \cite{bentley:pearls} apresenta um estudo detalhado, em estilo
bastante informal, embora preciso, de varia\coes\ sobre algoritmos de
particionamento. Entre elas, encontra-se o algoritmo de Bentley para
particionamento em tr\^es vias de Bentley, que \ee\ usado em 
\cite{bentley-sedgewick:ternary} em algoritmo de \quicksort\ tern\aa rio para
ordena\cao\ de strings.

\begin{ex}
	Detalhe o algoritmo de particionamento de tr\^es vias Bentley na 
	linguagem de comandos guardados e
	prove sua corre\cao.
\end{ex}

\begin{ex}
	Prove que no melhor caso o algoritmo de \quicksort\ demanda $Theta(m\lg
	m)$ compara\coes\ e movimentos de dados.
\end{ex}

\begin{ex}
	Prove que o algoritmo de \quicksort\ demanda $O(m^2)$ compara\coes\ de
	chaves.
\end{ex}



