intr_prog/introducao_ordenacao.html

<!--
 Introdução à Programação - 2017 - Prof. Leoônidas de Oliveira Brandão
 Introdução à ordenação
 LInE (Laboratory of Informatics in Education) - http://www.usp.br/line
 IME - USP
 Material didático
 Pode usar livrevemente este material para fins não comerciais, devendo sempre fazer referência à autoria.
 Sugestões/apontamento são bem vindos: leo@ime.usp.br (favor indicar no assunto "material de introducao 'a programacao")
 Prof. Leônidas de Oliveira Brandão
 http://www.ime.usp.br/~leo
 http://line.ime.usp.br
 http://www.matemtica.br
-->

  <meta http-equiv='Content-Type' content='text/html; charset=UTF-8'>
  <meta name='keywords' content='mac0122, material, professores, leonidas de oliveira brandao'>
  <link rel='stylesheet' type='text/css' href='css_img_js_conf/all.css'>
  <link rel='stylesheet' type='text/css' href='css_img_js_conf/line_introducao_programacao.css'>
  <script src="css_img_js_conf/defineLInE.js"></script> <!-- para referencias 'a documentos internos -->
<div class="pagina">


<!--
<center><p>[
  <a href="#" title=""></a> &nbsp; | &nbsp;
  <a href="#memoria" title=""></a> &nbsp; &nbsp;
 ]</p>
</center>
-->


<p class="secao">Introdução à ordenação</p>

<p>
Nesta seção examinaremos os algoritmos mais básicos para ordenação de uma lista de dados (vetores).
Os algoritmos examinados aqui não são eficientes e por isso para aplicações reais usualmente são implementados outros
(como <i>Ordenação Rápida/Quick Sort</i>, <i>Ordenação por Fusão/Merge Sort</i> ou <i>Ordenação por Monte/Heap Sort</i>).
O último a ser examinado (<a href="#insercao" title="metodo da insercao direta">Inserção</a>), é mais eficiente,
principalmente se os dados estiverem "quase-ordenados".
</p>

<p>
O problema é, dada uma sequência de valores (em lista ou vetor), ordenar crescente (ou decrescente) essa sequência.
Por exemplo, na figura abaixo, inicialmente os dados não estão ordenados <tt>{4, 2, 3, 0, 9, 3, 5, 7}</tt>.
Um algoritmo de ordenação que recebesse esse vetor com <tt>n=8</tt> valores, deveria trocar os valores
de posição de modo a conseguir a seguinte situação final para o vetor: <tt>{0, 2, 3, 3, 4, 5, 7, 9}</tt>.
</p>
<center><img src="img/ordenacao_vetor.png" title="vetor nao ordenado acima, abaixo o mesmo em ordem crescente"/>
  <br/>
  <i>Fig. 1. Ilustração dos dados na configuração inicial e na final (já ordenado
  <tt>V[0]<u>&lt;</u>V[1]<u>&lt;</u>...<u>&lt;</u>V[n-1]</tt>).</i><br/>&nbsp;<br/>
</center>
<p>
Para simplificar as explicações fixaremos um nome para o vetor e usaremos a notação <tt>V[i]</tt> para indicar o valor que está na posição <tt>i</tt> do vetor.
Também convencionaremos que a primeira posição do vetor seja <tt>V[0]</tt>, logo um vetor com <i>N</i> elementos terá o último deles na posição <tt>V[N-1]</tt>.
</p>

<p>
Os métodos que examinaremos são os conhecidos:
<i>Método da Bolha (Buble Sort)</i>, <i>Seleção Direta</i> e <i>Inserção Direta</i>.
</p>


<a name="bolha">
<p class="secao">Método da Bolha (ou "Pedregulho")</p>
</a>

<p>
A ideia do <b>método da Bolha</b> é inicia comparando os dois últimos elementos, o menor fica à esquerda, então comparar os
dois anteriores e fazer a mesma coisa, desse modo o <b>menor vai movendo-se para cima</b> (como as bolhas).
Mas também podemos fazer o "inverso", seguir empurrando o maior para baixo e assim, poderíamos apelidar essa variante de
<b>método do Pedregulho</b>.
</p>

<p>
Vamos detalhar a primeira fase do <b>método do Pedregulho</b>, nessa fase empurramos o maior do <tt>N</tt> elementos para a última posição.
O primeiro passo é comparar <tt>V[0]</tt> com <tt>V[1]</tt>,
se o valor em <tt>V[0]</tt> for maior que o valor em <tt>V[1]</tt>, troque seus valores (diremos apenas <tt>Se (V[0] &gt; V[1], troque-os</tt>).
O passo 2 é: <tt>Se (V[1] &gt; V[2], troque-os</tt> (logo <tt>V[2]</tt> terá o maior dos 3 primeiros).
O passo 3 é: <tt>Se (V[2] &gt; V[3], troque-os</tt> (logo <tt>V[3]</tt> terá o maior dos 4 primeiros).
Segue comparando 
<tt>V[i]</tt> com <tt>V[i+1]</tt>, até
o passo N-1: <tt>Se (V[N-2] &gt; V[N-1], troque-os</tt> (logo <tt>V[N-1]</tt> terá o maior dos 4 primeiros).
</p>

<p>
A figura abaixo ilustra os <i>7</i> primeiros passos, na <b>etapa 1</b>, do algoritmo para levar o maior elemento (considerando <i>N=8</i>) para a posição <i>8</i>.
</p>

<center><img src="img/ordenacao_vetor_bolha.png" title="primeira fase ordenacao Bolha: empurrar o maior"/>
  <br/>
  <i>Fig. 2. Ilustração do Método do Pedregulho, coluna da esquerda as quatro primeiras "descida" do tipo
  <tt>V[i]<u>&lt;</u>V[i+1]</tt>.</i><br/>
</center>

<p>
Note que na primeira imagem (acima, esquerda), existem os <i>8</i> na ordem inicial <tt>{4, 2, 3, 0, 9, 3, 5, 7}</tt>.
Cada passo de comparação dos pares de vizinhos está indicado por duas setas sobre os valores a serem comparados.
Na representação seguinte, o vetor é novamente apresentado, eventualmente tendo sido trocados os (se <tt>V[i]&gt;V[i+1]</tt>).
Na passo <i>7</i>, usamos apenas uma seta para indicar que o maior dentre todos os elementos foi para a última posição.
</p>

<p>
Mas, como o objetivo é ordenar, não apenas descobrir o maior, podemos usar a mesma ideia (de modo <i>indutivo</i>):
aplica-se o mesmo algoritmo (empurrar o maior para a última posição), mas considerando agora apenas os <i>7</i> primeiro elementos,
pois o maior já está na posição <i>8</i>.
Novamente, isso resultará no <i>segundo maior</i> na posição <i>7</i>
</p>

<p>
Mais uma vez (em geral) o vetor <b>não</b> está ordenado, mas podemos aplicar a mesma ideia mas <i>5</i> vezes:
para <tt>V[0]..V[6]</tt> (maior deles para <tt>V[6]</tt>);
para <tt>V[0]..V[5]</tt> (maior deles para <tt>V[6]</tt>);
para <tt>V[0]..V[4]</tt> (maior deles para <tt>V[6]</tt>);
para <tt>V[0]..V[3]</tt> (maior deles para <tt>V[6]</tt>);
para <tt>V[0]..V[2]</tt> (maior deles para <tt>V[6]</tt>);
para <tt>V[0]..V[1]</tt> (maior deles para <tt>V[1]</tt>).
</p>

<p>
Desse modo obtém-se o vetor em ordem crescente! Abaixo apresentamos o algoritmo do <i>Pedregulho (Bolha)</i> em <i>C</i> e em <i>Python</i>.
</p>

<p><center>
<table class="tbCodeLinCol">
 <tr><th colspan="3">Método de ordenação Bolha/Pedregulo em <i>C</i> e em  <i>Python</i> </th> </tr>
 <tr> 
     <th>Exemplo em <i>C</i></th>
     <th>Exemplo em <i>Python</i></th>
 </tr>
 <tr valign="top"><td><table class="tbCode">
   <tr><td><pre><tt class="com">// Ordena bolha/pedregulho</tt>
<tt class="com">#include</tt> &lt;stdio.h&gt;
<tt class="def">void</tt> imprimir (<tt class="tipo">int</tt> X[], <tt class="tipo">int</tt> n) {
  <tt class="tipo">int</tt> i;
  <tt class="fnc">printf</tt>("(");
  <tt class="cmd">for</tt> (i=0; i&lt;n; i++) <tt class="fnc">printf</tt>("%3d ", X[i]);</tt>
  <tt class="fnc">printf</tt>(")\n");
  }
<tt class="def">void</tt> ordPedregulho (<tt class="tipo">int</tt> V[], <tt class="tipo">int</tt> n) {
  <tt class="tipo">int</tt> i, j, aux;
  <tt class="cmd">for</tt> (i=0; i&lt;n; i++)
    <tt class="cmd">for</tt> (j=0; j&lt;n-i-1; j++)
      <tt class="cmd">if</tt> (V[j]>V[j+1]) { <tt class="com">// troque-os</tt>
        aux = V[j]; <tt class="com">// presevar V[j]</tt>
        V[j] = V[j+1];
        V[j+1] = aux; }
  }
<tt class="tipo">int</tt> main (void) {
  <tt class="tipo">int</tt> Y[] = { 4, 2, 3, 0, 9, 3, 5, 7 }; <tt class="com">// definir vetor dados</tt>
  <tt class="fnc">imprimir</tt>(Y, 8);</tt>
  ordPedregulho(Y, 8);</tt>
  <tt class="fnc">imprimir</tt>(Y, 8);</tt>
  }
   </tr></pre></td>
 </table></td>
   <td><pre><tt class="com"># Ordena bolha/pedregulho</tt>
<tt class="def">from</tt> __future__ import print_function; <tt class="com"># imprime sem mudar linha Python 2</tt>
<tt class="def">def</tt> imprimir (X, n) :
  <tt class="fnc">print</tt>("(", end="");
  <tt class="cmd">for</tt> i in range(n) :
    <tt class="fnc">print</tt>("%3d " % X[i], end="");</tt>
  <tt class="fnc">print</tt>(")");

<tt class="def">def</tt> ordPedregulho (V, n) :
  <tt class="cmd">for</tt> i in range(n) :</tt>
    <tt class="cmd">for</tt> j in range(n-i-1) :</tt>
      <tt class="cmd">if</tt> (V[j]>V[j+1]) : <tt class="com"># troque-os</tt>
        aux = V[j]; # preservar V[j]</tt>
        V[j] = V[j+1];</tt>
        V[j+1] = aux;</tt>

<tt class="fnc">def</tt> main () :
  V = [4, 2, 3, 0, 9, 3, 5, 7]; <tt class="com"># definir vetor dados</tt> 
  <tt class="fnc">imprimir</tt>(V,8);</tt>
  ordPedregulho(V, 8);</tt>
  <tt class="fnc">imprimir</tt>(V,8);</tt>

main();</pre></td>
   </tr>
   </table></td></tr>
</table></center>
</p>


<a name="selecao">
<p class="secao">Método da Seleção Direta</p>
</a>

<p>
A ideia o <b>método da Seleção Direta</b> é novamente deixar na última posição o maior elemento (ou o menor na primeira),
mas diferentemente do método da Bolha, nesse mantém-se fixado o último elemento, comparando-o com o primeiro, com o segundo e
assim por diante.
Considerando novamente um vetor com <i>8</i> elementos, após <i>7</i> comparações (e eventuais trocas), o maior deles estará na posição <i>8</i>.
</p>

<p>
Esse método está ilustrado na figura abaixo. Na primeira coluna estão os <i>7</i> passos para obter o maior elemento em <tt>V[7]</tt>.
Na coluna 2 estão os <i>6</i> passos para obter o segundo maior para <tt>V[6]</tt>.
Na coluna 3 estão os <i>5</i> passos para obter o terceiro maior para <tt>V[5]</tt> e
na coluna 4 estão os <i>4</i> passos para obter o quarto maior para <tt>V[6]</tt>.
Para finalizar o algoritmo deve-se fazer mais duas sequências de passos (ou <i>laços</i>),
fixando-se o elemento <i>3</i> para obter o 5-ésimo (<i>5=8-3</i>) maior e
fixando-se o elemento <i>2</i> para obter o 6-ésimo (<i>6=8-2</i>) maior.
</p>

<center><img src="img/ordenacao_vetor_selecao.png" title="primeira fase ordenacao Bolha: empurrar o maior"/>
  <br/>
  <i>Fig. 3. Ilustração do Método da Seleção Direta, coluna da esquerda os primeiros passos (na <b>etapa 1</b>),
  resultando em
  <tt>V[i]<u>&lt;</u>V[n-1]</tt>, <tt>i<u>&lt;</u>n-1</tt> (</tt>n=8</tt>).</i><br/>&nbsp;<br/>
</center>

<p>
Abaixo está uma implementação do método <i>Seleção Direta</i> em <i>C</i> e em <i>Python</i>.
</p>

<p><center>
<table class="tbCodeLinCol">
 <tr><th colspan="3">Método de ordenação Bolha/Pedregulo em <i>C</i> e em  <i>Python</i> </th> </tr>
 <tr> 
     <th>Exemplo em <i>C</i></th>
     <th>Exemplo em <i>Python</i></th>
 </tr>
 <tr valign="top"><td><table class="tbCode">
   <tr><td><pre><tt class="com">// Ordena Selecao Direta</tt>
<tt class="com">#include</tt> &lt;stdio.h&gt;
<tt class="def">void</tt> imprimir (<tt class="tipo">int</tt> X[], <tt class="tipo">int</tt> n) {
  <tt class="tipo">int</tt> i;
  <tt class="fnc">printf</tt>("(");
  <tt class="cmd">for</tt> (i=0; i&lt;n; i++) <tt class="fnc">printf</tt>("%3d ", X[i]);</tt>
  <tt class="fnc">printf</tt>(")\n");
  }
<tt class="def">void</tt> ordSelecao (<tt class="tipo">int</tt> V[], <tt class="tipo">int</tt> n) {
  <tt class="tipo">int</tt> i, j, aux;
  <tt class="cmd">for</tt> (i=n-1; i&gt;0; i--)
    <tt class="cmd">for</tt> (j=0; i&lt;i; j++)
      <tt class="cmd">if</tt> (V[j]>V[i]) { <tt class="com">// troque-os</tt>
        aux = V[j]; <tt class="com">// presevar V[j]</tt>
        V[j] = V[i];
        V[i] = aux;
        }
  }
<tt class="tipo">int</tt> main (void) {
  <tt class="tipo">int</tt> Y[] = { 4, 2, 3, 0, 9, 3, 5, 7 }; <tt class="com">// definir vetor dados</tt>
  <tt class="fnc">imprimir</tt>(Y, 8);</tt>
  ordSelecao(Y, 8);</tt>
  <tt class="fnc">imprimir</tt>(Y, 8);</tt>
  }
   </tr></pre></td>
 </table></td>
   <td><pre><tt class="com"># Ordena Selecao Direta</tt>
<tt class="def">from</tt> __future__ import print_function; <tt class="com"># imprime sem mudar linha Python 2</tt>
<tt class="def">def</tt> imprimir (X, n) :
  <tt class="fnc">print</tt>("(", end="");
  <tt class="cmd">for</tt> i in range(n) : 
    <tt class="fnc">print</tt>("%3d " % X[i], end="");</tt>
  <tt class="fnc">printf</tt>(")");

<tt class="def">def</tt> ordSelecao (V, n) :
  <tt class="cmd">for</tt> i in range(n-1, 0, -1) :</tt>
    <tt class="cmd">for</tt> j in range(i) :</tt>
      <tt class="cmd">if</tt> (V[j]>V[i]) : <tt class="com"># troque-os</tt>
        aux = V[j]; <tt class="com"># preservar V[j]</tt>
        V[j] = V[i];
        V[i] = aux;

<tt class="fnc">def</tt> main () :
  V = [4, 2, 3, 0, 9, 3, 5, 7]; <tt class="com"># definir vetor dados</tt> 
  <tt class="fnc">imprimir</tt>(V,8);</tt>
  ordSelecao(V, 8);</tt>
  <tt class="fnc">imprimir</tt>(V,8);</tt>

main();</pre></td>
   </tr>
   </table></td></tr>
</table></center>
</p>

<p>
Note que os comandos para trocar os conteúdos entre <tt>V[j]</tt> e <tt>V[i]</tt>
(subordinado ao <tt>if (V[j]&gt;V[i])</tt>) poderia ser evitado, bastaria mais duas variáveis auxiliares,
<tt>imax</tt> e <tt>max</tt>, respectivamente, para armazenar o índice do maior valor e o maior valor
(<tt>max = V[imax]</tt>).
Assim, ao final laço <tt>for j</tt> faríamos apenas uma troca (entre <tt>V[i]</tt> e <tt>V[imax]</tt>).
Nessa variante do algoritmo, o número de passos e de comparações é o mesmo, entretanto o número de trocas (geralmente) seria bem menor!
</p>


<a name="insercao">
<p class="secao">Método da Inserção Direta</p>
</a>

<p>
A ideia o <b>método da Inserção Direta</b> é um pouco diferentes do Bolha e Seleção, naqueles após cada laço interno um elemento maior
ficava em sua posição "definitiva", no Inserção não.
A ideia do <b>Inserção</b> é (na <b>etapa i de ordenação</b>): suponha que <tt>V[0]</tt> até <tt>V[i-1]</tt> esteja ordenado, então podemos estender a ordem
localizando o primeiro elemento, da direita para a esqueda, que <b>não</b> seja maior que <tt>V[i]</tt>, digamos que seja o
<tt>V[j]</tt>, então move-se todos eles uma posição para a sua direita, abrindo a posição <tt>V[j]</tt> para <b>inserir</b> o <tt>V[i]</tt>.
Esse princípio é ilustrado abaixo com <tt>j=3</tt>:
 <table><tr><td> &nbsp; &nbsp; </td> <td>
  1. <tt>V[0]<u>&lt;</u>V[1]<u>&lt;</u>V[2]</tt> odernados;<br/>
  2. <tt>V[3]</tt> libera seu espaço (cópia em <tt>aux</tt>);<br/>
  3. todos os elementos com valor estritamente maior que <tt>aux</tt> "dão um passo para a direita";<br/>
  4. a posição <tt>i=0</tt> é liberada para inserir ali <tt>aux</tt> (estendendo a ordenação para 4 elementos).
  </td>
  <td> &nbsp; &nbsp; <img src="img/ordenacao_vetor_insercao1.png" title="ideia da Insercao Direta"/>
  <br/>
  <i>Fig. 4. Ilustração dos "deslocamentos" para <b>inserir</b> a chave (inicialmente) na posição <tt>V[3]</tt> 
  para a posição correta (<tt>V[0]<u>&lt;</u>V[1]<u>&lt;</u>V[2]<u>&lt;</u>V[3]</tt>.</i>  
  </tr></table>
</p>


<p>
Esse método está ilustrado na figura abaixo. Na primeira coluna estão as <i>3</i> instruções para 
obter uma ordenação com os <i>2</i> primeiros elementos.
Na coluna 2 estão as <i>4</i> instruções para obter ordenação dos <i>4</i> primeiros elementos e
na coluna 3 estão as <i>5</i> instruções para obter ordenação dos <i>5</i> primeiros elementos.
</p>

<center><img src="img/ordenacao_vetor_insercao2.png" title="os 3 primeiros blocos de passos para ordenacao por Insercao"/>
<br/>
<i>Fig. 5. Ilustração do Inserção Direta: na primeira coluna representa a <b>etapa 1 de ordenação</b> a chave
é o <tt>2</tt> na posição <tt>V[1]</tt>; na segunda a chave
é o <tt>0</tt> na posição <tt>V[3]</tt>.</i><br/>&nbsp;<br/>
</center>

<p>
É importante notar que se os dados estiverem já ordenados, serão realizadas apenas <tt>n=7</tt> operações!
De modo geral, se a <i>etapa de ordenação i</i> resultar em ordenação completa dos dados, deste ponto em diante,
serão feitas apenas <i>n-i-1</i> comparações e nenhuma troca (!).
Pode-se usar uma 
<a href="#" onclick="trocaPagina('introducao_depuracao_codigos.html#bandeiras')" title="ver conceito de bandeiras">bandeira</a>
para identificar tal fato e finalizar o algoritmo.
<br/>
Por exemplo, na última coluna da figura 5, se o valor em <tt>V[4]</tt> fosse <tt>5</tt> (ou qualquer outro valor maior),
haveria apenas três instruções (independe do valor <i>5</i>):
copiar <tt>V[3]</tt> para <tt>aux</tt>,
comparar <tt>aux</tt> com <tt>V[2]</tt> e, como <tt>aux</tt> é maior (ou igual), finalizaria,
copiando <tt>aux</tt> novamente para <tt>V[3]</tt>.
</p>

<p>
Abaixo está uma implementação do método <i>Inserção Direta</i> em <i>C</i> e em <i>Python</i>.
</p>

<p><center>
<table class="tbCodeLinCol">
 <tr><th colspan="3">Método de ordenação Inserção Direta em <i>C</i> e em  <i>Python</i> </th> </tr>
 <tr> 
     <th>Exemplo em <i>C</i></th>
     <th>Exemplo em <i>Python</i></th>
 </tr>
 <tr valign="top"><td><table class="tbCode">
   <tr><td><pre><tt class="com">// Ordena Insercao Direta</tt>
<tt class="com">#include</tt> &lt;stdio.h&gt;
<tt class="def">void</tt> imprimir (<tt class="tipo">int</tt> X[], <tt class="tipo">int</tt> n) {
  <tt class="tipo">int</tt> i;
  <tt class="fnc">printf</tt>("(");
  <tt class="cmd">for</tt> (i=0; i&lt;n; i++) <tt class="fnc">printf</tt>("%3d ", X[i]);</tt>
  <tt class="fnc">printf</tt>(")\n");
  }
<tt class="def">void</tt> ordInsercao (<tt class="tipo">int</tt> V[], <tt class="tipo">int</tt> n) {
  <tt class="tipo">int</tt> i, j, aux;
  <tt class="cmd">for</tt> (i=1; i&lt;n; i++) {
    aux = V[i]; <tt class="com">// "abrir espaco" copiando V[i]</tt>
    j = i-1;
    <tt class="cmd">while</tt> (j &gt; -1 && V[j] &gt; aux) { <tt class="com">// mova para direita os maiores que aux</tt>
      V[j+1] = V[j]; <tt class="com">// mover para direita V[j]</tt>
      j -= 1;
      }
    V[j+1] = aux; <tt class="com">// coloque aux na posicao correta</tt>
    }
  }
<tt class="tipo">int</tt> main (void) {
  <tt class="tipo">int</tt> Y[] = { 4, 2, 3, 0, 9, 3, 5, 7 }; <tt class="com">// definir vetor dados</tt>
  <tt class="fnc">imprimir</tt>(Y, 8);</tt>
  ordInsercao(Y, 8);</tt>
  <tt class="fnc">imprimir</tt>(Y, 8);</tt>
  }
   </tr></pre></td>
 </table></td>
   <td><pre><tt class="com"># Ordena Insercao Direta</tt>
<tt class="def">from</tt> __future__ import print_function; <tt class="com"># imprime sem mudar linha Python 2</tt>
<tt class="def">def</tt> imprimir (X, n) :
  <tt class="fnc">print</tt>("(", end="");
  <tt class="cmd">for</tt> i in range(n) :
    <tt class="fnc">print</tt>("%3d " % X[i], end="");</tt>
  <tt class="fnc">printf</tt>(")");

<tt class="def">def</tt> ordInsercao (V, n) :
  <tt class="cmd">for</tt> i in range(1, n) :</tt>
    aux = V[i]; <tt class="com"># "abrir espaco" copiando V[i]</tt>
    j = i-1;
    <tt class="cmd">while</tt> (j &gt; -1 and V[j] &gt; aux) : <tt class="com"># "mova" para direita os maiores que aux</tt>
        V[j+1] = V[j]; <tt class="com"># mover para direita V[j]</tt>
        j -= 1;
    V[j+1] = aux; <tt class="com"># coloque aux na posicao correta</tt>

<tt class="fnc">def</tt> main () :
  V = [4, 2, 3, 0, 9, 3, 5, 7]; <tt class="com"># definir vetor dados</tt> 
  <tt class="fnc">imprimir</tt>(V,8);</tt>
  ordInsercao(V, 8);</tt>
  <tt class="fnc">imprimir</tt>(V,8);</tt>

main();</pre></td>
   </tr>
   </table></td></tr>
</table></center>
</p>

<p>
</p>



<p>
  Bem, em resumo é isso. Experimente copiar esses códigos, tente algumas modificações, teste até estar seguro de ter compreendido.
</p>


  <p class="autoria">
    <a href="https://www.ime.usp.br/~leo" target="_blank" title="seguir para a pagina do prof. Leônidas">Leônidas de Oliveira Brandão</a><br/>
    <a href="http://www.ime.usp.br/~leo" target="_blank" title="seguir para a página do LInE">http://line.ime.usp.br</a>
  </p>

  <p class="rodape">
    <b>Alterações</b>:<br/>
    2020/08/20: acerto no formato<br/>
    2020/08/15: novo formato, pequenas revisões<br/>
    2020/08/12: novo formato, pequenas revisões<br/>
    2020/06/14: inserção de rótulos para as figuras<br/>
    2019/06/16: versão inicial
  </p>


</div>