\section{Ordena\c c\~ao por inser\c c\~ao}

O processo de ordena\cao\ por inser\cao\ consiste em repetidamente inserir
elementos da \sqn\ em quest\ao\ em uma sub\sqn\ previamente ordenada. Isso
d\aa\ basicamente o mesmo \emph{template} que a soma de elementos de uma \sqn:

\begin{itemize}
	\item 	para somar $n$ elementos, acumule os primeiros $n-1$ e 
                some o resultado com o elemento restante.
	\item para ordenar uma \sqn\ de $n$ elementos, ordene os primeiros $n-1$
		e insira em ordem na sub\sqn\ resultante o elemento restante.  
\end{itemize}

Essa observa\cao\ leva \`a invariante do loop principal:

\[ P\dfn \lele 0im \land \incr S0i \] 

Os elementos restantes da deriva\cao\ s\ao\ \oo bvios:
\begin{itemize}
	\item vari\aa vel derivada: $T\dfn m-i$, que o n\uu mero de elementos
		ainda n\ao\ inseridos;
	\item a guarda do loop: $B\dfn m-i> 0$, que estabelece o limite
		da computa\cao.
	\item a condi\cao\ inicial: $i = 1$, assumindo que a sub\sqn\ com
		o primeiro elemento est\aa\ ordenada. Note que mesmo que a
		\sqn\ seja vazia, esta inicializa\cao\ ainda \ee\ consistente
		com a guarda do loop.
	\item a transi\cao\ do loop, realizada at\ee\ o ponto-fixo, deve inserir
		novo elemento na por\cao\ ordenada e restabelecer a invariante:

\begin{verbatim}
      insert(S,i)
     ; i:=i+1
\end{verbatim}
\end{itemize}

Ao final do algoritmo, a condi\cao\ $R$ estabelecida deve ser a mesma
de qualquer algoritmo de ordena\cao:
\begin{itemize}
	\item $\incr S0m$
	\item $S$ \ee\ uma permuta\cao\ da \sqn\ inicial.
\end{itemize}

Para derivar o algoritmo inser\cao\ de um elemento na por\cao\ ordenada, leve
em conta:
\begin{itemize}
	\item a situa\cao\ inicial:
		$\incr S0i$
	\item que se $S.i$ for preservado em alguma varia\aa vel tempor\aa ria  
		$tmp$
		e encontrada a posi\cao\ correta para ele, a sub\sqn\ poder\aa\
		ter o seguinte estado antes da inser\cao:
		\begin{itemize}
		     \item  trecho inicial n\ao\ alterado:
			     $\incr S0j$
		     \item{buraco aberto para inser\cao\ de } $tmp$ em $j$
		     \item trecho que foi deslocado para a direita:
			     $\incr S{j+1}{i+1}$ 
		\end{itemize}
\end{itemize}

\lstset{language=Pascal,keywordstyle=\bfseries,escapechar=\@,
        keywords={do,od,if,fi,Seq,Int,cand,initially,Var,let,in,tel},
        caption={[t]Linear search}}
\begin{figure}
\lstinputlisting{inssort.tex}
\caption{Ordena\cao\ por inser\cao}\label{inssort}
\end{figure}

\begin{ex}
	Prove a corre\cao\ do algoritmo da \rffig{inssort}.
\end{ex}


\subsection{Complexidade de \emph{insert}}
O trecho que insere um novo elemento em uma sub\sqn\ de $i$ itens previamente 
ordenada pode realizar:
\begin{itemize}
	\item uma \uu nica compara\cao: caso em que o novo item \ee\ maior que
		todos os outros presentes na sub\sqn;
	\item comparar o novo item com todos os outros e movimentar cada um
		deles para a direita, produzindo: $m$ compara\coes\ de itens,
		$i+1$ movimentos de itens, $i$ transi\coes.
\end{itemize}

\subsection{Complexidade do \inssort}
O algoritmo \inssort\ chama $m$ para ordenar uma \sqn\ de $m$ elementos.

\begin{ex}
	Prove que se $C(n)$ e $M(n)$ s\ao\ respectivamente n\uu mero de 
	compara\coes\ e movimentos para ordenar uma \sqn\ de $m$ itens usando
	\inssort, ent\ao:
	\begin{gather*}
		C(m) \in O(m^2)\\
		M(m) \in O(m^2)
	\end{gather*}
\end{ex}

O \emph{lower bound} para resolver uma classe de  problemas $P$ 
\begin{definition}
	Um algoritmo $A$ para resolver uma classe de problemas $P$ \ee\ 
	\oo timo em rela\cao\ a um crit\ee rio de complexidade $C$ \dfn\
	$A$ resolve qualquer problema da classe $P$ de tamanho $m$ com
	complexidade 
	igual ao lower bound da classe $P$.
\end{definition}
\begin{ex}
	Prove que uma 
\end{ex}<++>
