\section{Ordena\c c\~ao por sele\c c\~ao}
Algoritmos de ordena\cao\ por sele\cao, da mesma forma que o \inssort,
assume uma se\cao\ do vetor ordenada e a ele acresentam, a cada transi\cao\
o novo elemento: desta vez, o maior elemento presente na se\cao\ n\ao\ 
ordenada. Como antes o objetivo \ee\ estabelecer:

\[ R\dfn\ \incr S0m \land S\in \pi.B\]
onde $B$ \ee\ o valor inicial do vetor a ordenar e $\pi.B$ \ee\ o
conjunto de todas as permuta\coes\ de $B$.

Nos algoritmos de ordena\cao\ por sele\cao\ generaliza-se a propriedade $R$,
para obter a invariante ou parte dela, trocando, por exemplo, a constante
$0$ por uma vari\aa vel $i$.

\[ P_0 \dfn\ \lele 0im \land \incr S{i+1}m \land S\in \pi.B\]

Dado que $P_0$ estabelece que a se\cao\ $S(i+1..m-1)$ est\aa\ ordenada, \ee\
razo\aa vel assumir que essa se\cao\ n\ao\ ser\aa\ mais alterada e que outros
elementos presentes em $S$ s\ao\ menores do $S(i+1)$. Racioc\ii nio an\aa logo
seria usado para construir a ordena\cao\ se a hip\oo tese fosse de a se\cao\
ordenada de $S$ \ee\ inicial e que os elementos que n\ao\ est\ao\ nessa
se\cao\ s\ao\ maiores do que os que nela est\ao\ presentes.
\subsection{Em tempo quadr\'atico: \selsort}
No algoritmo \selsort, o novo elemento adicionado a cada passo \ee\
obtido pela escolha do maior elemento presente na se\cao\ n\ao\ ordenada.
A invariante \ee:
\[ P\dfn\ \lelt 0im \land \incr S{i+1}m\land S(i+1)>S(0..i)\land S\in \pi.B\]

A varai\aa vel derivada \ee\ $T$
\[ T\dfn\ i\]

A guarda do loop estabelece que, quando s\oo\ existe um elemento
na se\cao\ n\ao\ ordenada, o loop atinge seu ponto-fixo: uma se\cao\ de
um elemento est\aa\ ordenada.

\[ G\dfn\ i>0\]

\begin{figure}
          \lstinputlisting{selsort.tex}
          \caption{Algoritmo \selsort}\label{selsort}
\end{figure}


O algoritmo est\aa\ na \rffig{selsort}. Nele \textbf{maxpos} estabelece a
posi\cao\ de \emph{supremum} para a se\cao\ n\ao\ ordenada. Esse procedimento
poderia ser definido como:
\[ maxpos(S,i) \dfn\ j:\!- \bndA{k}{\lele 0ki}{S.j\ge S.k}\]

A defini\cao\ determin\ii stica de $maxpos$ est\aa\ na \rffig{maxpos}.

\begin{figure}
          \lstinputlisting{maxpos.tex}
          \caption{Algoritmo para sele\cao\ de m\aa ximo}\label{maxpos}
\end{figure}

\begin{theo}
	Prove que $maxpos$ definido na \rffig{maxpos} calcula um $j$ tal que
	$\lele 0ji$ e $S.j\ge S(0..i)$.
\end{theo}

\subsubsection{A complexidade de \emph{maxpos}}
O algoritmo da \rffig{maxpos} n\ao\ movimenta nenhum elemento e,  na verdade,
no caso de a \sqn\ j\aa\ estar ordenada, \selsort\ n\ao\ realiza movimentos
de chaves. Por outro lado, $maxpos$ sempre realiza $i-1$ compara\coes: 
$maxpos$ v\^e cada se\cao\ que recebe como desconhecida e, por isso, precisa
comparar seu \uu ltimo elemento com todos os outros para obter o supremum
da se\cao.

\subsubsection{Complexidade do \selsort}
Cada transi\cao\ do algoritmo da \rffig{selsort} realiza, no m\aa ximo, uma
troca de chaves: o que daria dois movimentos de chaves. Logo, o algoritmo
realiza de zero a $2m$ movimentos de chaves.

O n\uu mero de compara\coes\ realizadas \ee\ dado por $C(m)$ abaixo:
\[ C(m) = (\bnd{+}{i}{\lele 1im}{i}\in \Theta(m^2)\]

Em resumo, independentemente da \sqn\ dado, \selsort\ sempre demanda $m^2$
transi\coes\ e compara\coes, onde $m$ \ee\ o n\uu mero de itens na \sqn. Isso
est\aa\ muito longe do \emph{lower-bound} poss\ii vel para ordena\cao\ por
compara\cao\ que demanda $\Omega(m\lg m)$ compara\coes.
 

\subsection{Em tempo \oo timo: \heapsort}
O problema essencial do m\ee todo \selsort\ parece ser o fato de que cada
transi\cao\ v\^e a se\cao\ do vetor como totalmente nova: nenhum cohnecimento
\ee\ trazido da transi\cao\ anterior. Para melhorar o desempenho do m\ee todo
ser\aa\ necess\aa rio considerar a possibilidade de:
\begin{itemize}
	\item manter a se\cao\ a ser pesquisada, na busca de elemeto m\aa ximo,
		em uma estrutura que permite que a sele\cao\ seja feita em
		tempo constante: se n\ao\ for constante, crescer\aa\ com o
		tamanho da se\cao\ e o comportamento quadr\aa tico
		reaparecer\aa;
	\item garantir que a estrutura possa ter suas propriedades invariantes
		rapidamente restauradas ap\oo s a opera\cao\ de extra\cao\ de um
		m\aa ximo;
	\item dado que se objetiva um tempo $O(m\lg m)$ para o processo completo
		de ordena\cao\ e que o \emph{template} geral do \selsort\
		ser\aa\ mantido, esta \ee\ uma tentativa de melhorar seu
		desempenho e n\ao\ de descart\aa\-lo, cada transi\cao, composta
		pela extra\cao\ do m\aa ximo e ajuste da estrura \`as suas
		propriedades invariantes, deveria demandar $O(\log i)$
		opera\coes: isso garantiria um total de opera\coes\ de
		\[ (\bnd{+}{i}{\lele 1im}{\lg i}) \in O(m\lg m)\]
           
\end{itemize}

Mesmo  sem considerar concretamente nenhuma estrutura, d\aa\ para
antecipar uma invariante para o novo algoritmo:
\[ logstruct.S,0,i \land \incr S{i+1}m \land S\in \pi.B\]

onde a propriedade $logstruct$ \ee\ a invariante de uma estrutua que:
\begin{itemize}
	\item permite extra\cao\ de um m\aa ximo em $O(1)$;
	\item permite ajuste \aa\ invariante em $O(\lg i)$.
\end{itemize}

A estrutura a ser usada \ee\ um heap e o algoritmo ser\aa\ por isso
denominado \emph{\heapsort}. O heap ter\aa\ a seguinte propriedade invariante:

\begin{align*}
	heap.S,i,m \dfn\quad&\bndA{j}{\lele ijm\land 2j<m}{S.j\ge S.2j}\\
	& \bndA{j}{\lele ijm\land 2j+1<m}{S.j\ge S(2j+1)}
\end{align*}


Um heap \ee\ uma \bintree\ balanceada, qualquer \emph{path} da raiz a uma folha
tem comprimento $O(\lg m)$ em que a raiz de qualquer sub\tree\ \ee\ maior ou
igual do que qualquer outro elemento dessa sub\tree: isso garante localiza\cao\
e extra\cao\ do m\aa ximo em $O(1)$, afinal ele estar\aa\ localizado na raiz
do heap. A acomoda\cao\ do heap em um array, importante para garantir que
o processo de ordena\cao\ ocorre no pr\oo prio array dado, consiste em
representar os dois filhos de  uma sub\tree\ com raiz na posi\cao\ $i$ como
\tree s, heaps na verdade, com ra\ii zes em $2i$ e $2i+1$.

A invariante do \heapsort\ \ee\ a propriedade $P$
\[ P\dfn\ \lelt 0im \land heap.S,0,i \land \incr S{i+1}m \land S\in \pi.B\]

\begin{figure}
          \lstinputlisting{heapsort.tex}
          \caption{Algoritmo \heapsort}\label{heapsort}
\end{figure}

O algoritmo \emph{heapsink} \ee\ respons\aa vel por restaurar o heap ap\oo s
a extra\cao\ do elemento da raiz: ap\oo s a troca que leva o m\aa ximo para 
a posi\cao\ final do heap, existe um elemento a menos na estrutura e o elemento
que se encontra na raiz est\aa\ fora de ordem. O algoritmo est\aa\ na
\rffig{heapsink}.

\begin{figure}
          \lstinputlisting{heapsink.tex}
	  \caption{Algoritmo \emph{heapsink}}\label{heapsink}
\end{figure}

\begin{ex}
	Prove que \emph{heapsink} restaura a propriedade de heap na se\cao\
	n\ao\ ordenada do array.
\end{ex}

\begin{ex}
	Prove que se o heap cont\ee m $i$ elementos, ent\ao\ \emph{heapsink}
	demanda $O(\lg i)$ transi\coes.
\end{ex}

O heap inicial \ee\ constru\ii do pelo algoritmo \emph{heapbuild}, na
\rffig{heapbuild}.

\begin{figure}
          \lstinputlisting{heapbuild.tex}
	  \caption{Algoritmo \emph{heapbuild}}\label{heapbuild}
\end{figure}





\begin{ex}
	Prove que \emph{heapsink} demanda $O(\lg(m-i))$ transi\coes,
	compara\coes\ e movimentos de chaves
\end{ex}

\begin{ex}
	Prove que \emph{heapbuild} demanda
	\[ (\bnd{+}{i}{\lelt 1im}{\lg (m-i)})= \lg(m!)\in O(m\lg m)\]
	transi\coes.
\end{ex}

\begin{ex}
	Prove que o \heapsort\ demanda 
	\[ (\lg m!) + (\bnd{+}{i}{\lelt 1im}{\lg(m-i)})\in O(m\lg m)\]
	transi\coes, movimentos e compara\coes\ de chaves.
\end{ex}

\begin{ex}
	Prove o \heapsort\ \ee\ um algoritmo \oo timo para o problema de 
	ordena\cao\ baseado em compara\cao.
\end{ex}
