Logica de Programação
Autor: itachi | Publicado: 2011-09-01T15:06:00-07:00



  Apostila Completa de Estruturas de DadosAlgoritmos
Conceitos
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->É um conjunto de instruções&nbsp; ou&nbsp; comandos que, quando executados , levam a um conjunto finito de ações.<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->É um conjunto ordenado de instruções que quando seguidas desempenham uma tarefa especifica.
Características<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->È rigoroso em sua definição<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Legibilidade<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Portabilidade
Programa.
É uma adaptação ou codificação de um algoritmo atendendo as regras de uma linguagem especifica.
Estrutura Básica de um Algoritmo
Um Algoritmo é normalmente dividido em 2 partes:
A Primeira parte é aonde será declaradas tudo o que é necessário      para a execução do algoritmo. Esta parte vai desde a palavra INICIO até a      Paravra PROCEDA.
A segunda parte é aonde serão colocados os comandos que serão      executados pelo Algoritmo.Esta parte se inicia com a Palavra PROCEDA e vai      até a palavra FIM.

Exemplo:
INICIO
Primeira Parte
PROCEDA
Segunda Parte
FIM.
É algo muito parecido com uma receita de bolo, aonde primeiro colocamos os ingredientes, e depois colocamos o modo de preparo , aonde detalhamos os procedimentos necessários para o preparo da receita.A única diferença é que no lagoritmo procuramos fazer a “receita” de acordo com uma linguagem especifica. O uso desta linguagem evita que sejam feitas interpretações diferentes da mesma sentença como veremos a seguir:    
Problemas de Narrativa:
Utilização do Não, somente, mas, e/ou, A menos que: 
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Conforme as palavra utilizadas para descrever uma função , poderão surgir interpretações diversas como nos exemplos abaixo:<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->“Somar A e B a menos que A seja menor que B aonde neste caso subtrair A de B”
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->“Somar A e B , entretanto se a for menor que B a resposta será a diferença entre A e B”
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->“Somar A e B mas subtrair A de B quando A for menor que B”
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->“O Total é a soma de A e B , somente quando A for menor é que a diferença deve ser utilizada no total”
Até , acima, abaixo:
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->“Abaixo de 20 unidades não há desconto, acima de 20 unidades da direito a 5% de desconto”<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->O que acontece com exatamente vinte unidades?<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Para solucionar este problema utilizar os operadores relacionais:
Ambigüidade do E/OU
“Clientes regulares que adquirirem mais de 1 Milhão e que tem um bom histórico de pagamento ou que estão conosco a mais de 20 anos devem receber tratamento especial”
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Dependendo da entonação da frase podem surgir interpretações diferentes.
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Adjetivos indefinidos:O que é um bom Histórico?O que é um cliente regular?
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->A frase “bom histórico” implica na existência de um Mau histórico, ambos deverão ser definidos?
Como pode ser visto acima a utilização da linguagem coloquial pode gerar diversas interpretações, e também muitas duvidas. Desta forma faz-se necessário a utilização de uma linguagem mais próxima a lógica dos computadores. E também , com&nbsp;&nbsp; uma linguagem bem parecida com as linguagens de programação, fica mais facil a transformação do algoritmo em um programa. O Algoritmo é então um intermediário entre a lingagem coloquial utilizada normalmente , e as linguagens de programação em outras palavras “Portugol”   Problemas de Interpretação:




<!--[if gte vml 1]><v:shapetype
 id="_x0000_t75" coordsize="21600,21600" o:spt="75" o:preferrelative="t"
 path="m@4@5l@4@11@9@11@9@5xe" filled="f" stroked="f">                                               <v:shape id="_x0000_i1025" type="#_x0000_t75" style='width:277.5pt;
 height:336.75pt' o:ole="" o:bordertopcolor="this" o:borderleftcolor="this"
 o:borderbottomcolor="this" o:borderrightcolor="this">  <v:imagedata src="file:///C:\Users\ITALO-~1\AppData\Local\Temp\msohtmlclip1\01\clip_image001.png"
  o:title=""/>         <![endif]--><!--[if !vml]--><!--[endif]--><!--[if gte mso 9]>  <o:OLEObject Type="Embed" ProgID="PBrush" ShapeID="_x0000_i1025"
  DrawAspect="Content" ObjectID="_1376409069">   <![endif]-->   Itens fundamentais:
Para que possamos entender e desenvolver algoritmos vamos precisar de alguns conceitos básicos:
Variáveis
Uma variável corresponde a uma área de memória , cujo conteúdo varia durante a execução do algoritmo.Devemos encarar uma variável como o endereço de memória aonde esta guardada uma determinada informação. Esta informação pode ser de diversões tipos, mas somente um tipo de cada vez. O algoritmo poderá alterar este valor, de acordo com as suas instruções, quantas vezes forem necessárias, por isto elas são chamadas variáveis. 
Tipos de Dados
Todos os dados processados por um algoritmo devem ser previamente definidos, isto porque o computador precisa saber previamente o tipo e o tamanho da informação que será processada.Como já foi visto anteriormente, nós vamos armazenar estes dados dentro de variáveis, para que possamos alterar o seu valor durante a execução do algoritmo. Sendo assim , cada variável deverá ser declarada previamente e com um tipo já definido que deverá ser um dos tipos abaixo, ou uma de suas variações que serão vistas posteriormente. 
Nomes de Variáveis
Para que possamos declarar uma variável devemos dar-lhe um nome. Dentro do algoritmo , toda vez que eu precisar usar o valor armazenado nesta variável , eu vou referencia-la pelo seu nome.
Regras para Nomes de Variáveis:
<!--[if supportFields]><span style='font-size:12.0pt;mso-bidi-font-size:
10.0pt'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Os nomes das variáveis devem representar o que será guardado dentro dela<!--[if supportFields]><span style='font-size:12.0pt;mso-bidi-font-size:
10.0pt'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O primeiro caracter de um nome deverá ser sempre alfabético<!--[if supportFields]><span style='font-size:12.0pt;mso-bidi-font-size:
10.0pt'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Não podem ser colocados espaços em branco no nome de variáveis, usar o UNDERSCORE.<!--[if supportFields]><span style='font-size:12.0pt;mso-bidi-font-size:
10.0pt'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; A declaração de uma variável é feita no algoritmo informando o seu nome, seguido pelo seu tipo, separados por ":"   
Tipos de Dados Primitivos
São os tipos de dados mais comuns, e que podem dar origem a outros tipos de dados mais complexos.
InteiroNúmeros inteiros maiores ou menores que 0 representados por 2 bytes, em uma faixa que vai de&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; -32.768 até 32.767.
Declaração:
NUMERO : INTEIRO
No exemplo acima foi declarada uma variável do tipo INTEIRO que atende pelo nome de "NUMERO"
RealConjunto dos números racionais. representado por 4 bytes.
Declaração:
SALÁRIO : REAL
No exemplo acima foi declarada uma variável do tipo REAL&nbsp; com o nome de "SALÁRIO".
Caractere (Char)Conjunto dos caracteres alfanuméricos (números , letras , símbolos, etc).Representado por apenas um byte.Note que as variáveis do tipo CHAR podem armazenar apenas 1 caracter.
Declaração:
SEXO : CHAR
No exemplo acima foi declarada uma variável do tipo CHAR&nbsp; com o nome "SEXO"

LógicoQuando assume apenas 2 valores:<!--[if supportFields]><b
style='mso-bidi-font-weight:normal'><span style='font-size:12.0pt;mso-bidi-font-size:
10.0pt'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp; FALSO <!--[if supportFields]><b
style='mso-bidi-font-weight:normal'><span style='font-size:12.0pt;mso-bidi-font-size:
10.0pt'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp; VERDADEIRO
DeclaraçãoFLAG : LÓGICO
No exemplo acima, foi declarada uma variável do tipo LÓGICO&nbsp; com o nome de FLAG.   
Agregados de Dados
Os agregados são estruturas formadas a partir dos tipos de dados primitivos, e que permitem o processamento de informações mais aprimoradas, são eles:
Cadeia de Caracteres (String)
É um agradado de dados homogêneo, ou seja, usa somente um tipo primitivo, aonde todos os elementos são do tipo caractere (CHAR)
Declaração:
NOME_CLI : STRING [ 40 ]No exemplo acima foi declarada uma variável do tipo STRING , que poderá ter no máximo 40 posições e o seu nome é NOME_CLI

Matriz
É um agregado de dados do tipo homogêneo , aonde todos os elementos podem ser de qualquer tipo , desde que todos os componentes sejam do mesmo tipo.
Declaração:
NUMERO : MATRIZ [ 4 , 5 ] DE INTEIRO
No exemplo acima , foi declarada uma MATRIZ com 4 colunas e 5 linhas , aonde todos os elementos serão do tipo INTEIRO. Note que o primeiro numero sempre representa o numero máximo de colunas que uma matriz pode ter, e o segundo numero representa o numero máximo de linha que uma matriz pode ter.
Note que podem existir matrizes unidimensionais, os chamados vetores. Neste caso a matriz possui apenas linhas ou colunas. neste caso não será necessário informar a coluna e a linha , mas somente um numero , não importando se ele representa a quantidade de colunas ou linhas.
   
Registros
É o único agregado de dados heterogêneo, ou &nbsp;seja pode combinar dados de diferentes tipos em uma única estrutura.
Declaração:
REG_DADOS : REGISTRONOME : STRING [ 40 ]SEXO : CHARIDADE : INTEIROSALARIO : REALFIM_REGISTRO
Note que o REGISTRO é formado por 4 CAMPOS, e cada campo é de um tipo diferente, entretanto , todos os campos fazem parte de uma única estrutura, que atende pelo nome de REG_DADOS.
Além das variáveis existem outros elementos que irão fazer parte dos algoritmos.
Declaração de Variáveis:
Exercício 01
Declare variáveis que sejam capazes de armazenas as seguintes informações
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Sua Idade<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->A Média entre 2 numeros<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->O seu Salário<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Seu nome, numero, nota do primeiro bimestre, nota do segundo bimestre e media final<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Os 12 meses dos ano (Só o numro do mês) com os sues respeqtivoas números de dias
Variaveis:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Nome; String;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Media: real&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Salario:real&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 
Comentários.
O comentário é um texto delimitado por chaves, cuja função é explicar com mais clareza alguma parte especifica do algoritmo. O comentário é um texto que não deve ser levado em consideração na hora de executar o algoritmo, ele serve apenas para dar informações adicionais a leitura do algoritmo.   
Operadores
Operadores são sinais utilizados nos algoritmos para indica a realização de operações que podem ser de três categorias:
<!--[if supportFields]><b
style='mso-bidi-font-weight:normal'><span style='font-size:12.0pt;mso-bidi-font-size:
10.0pt'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp; Aritméticas<!--[if supportFields]><b
style='mso-bidi-font-weight:normal'><span style='font-size:12.0pt;mso-bidi-font-size:
10.0pt'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp; Relacionais<!--[if supportFields]><b
style='mso-bidi-font-weight:normal'><span style='font-size:12.0pt;mso-bidi-font-size:
10.0pt'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp; Lógicas
Operadores Aritméticos
Servem para realizar operações com números inteiros ou reais.são eles:
  
      OPERADOR      SINAL      PRIORIDADE  
      ADIÇÃO      +      3  
      SUBTRAÇÃO      -      3  
      MULTIPLICAÇÃO      *      2  
      DIVISÃO      /      2  
      POTÊNCIA      <!--[if supportFields]><span
  style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
  field-begin'>SYMBOL 173 \f &quot;Symbol&quot;<span
  style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
  style='mso-element:field-end'><![endif]-->      1  

Operadores Relacionais
São operadores que servem para estabelecer relações entre variáveis do mesmo tipo.São eles
  
      OPERADOR      SINAL      PRIORIDADE  
      IGUAL      =      1  
      DIFERENTE      &lt; &gt;      1  
      MENOR   QUE      &lt;&nbsp;      1  
      MAIOR   QUE      &gt;&nbsp;      1  
      MAIOR   OU IGUAL      &gt; =      1  
      MENOR   OU IGUAL      &lt; =      1  

   Operadores Lógicos
São operadores utilizados para unir duas relações criadas através dos operadores relacionaissão eles:
  
      OPERADOR      SIGNIFICADO      PRIORIDADE  
      
E      &nbsp;ESPECIFICA QUE TODAS AS CONDIÇÕES   RELACIONADAS DEVEM SER VERDADEIRAS PARA QUE O CONJUNTO SEJA VERDADEIRO      1  
      
OU      &nbsp;ESPECIFICA QUE SE APENAS UMA DAS CONDIÇÕES   RELACIONADAS FOR VERDADEIRA , O RESULTADO DELAS TAMBÉM SERÁ VERDADEIRO.      1  
      NAO      &nbsp;ESPECIFICA A NEGAÇÃO DA CONDIÇÃO   RELACIONADA, OU SEJA A INVERSÃO DOS VALORES      1  

Resumo das Prioridades.

  
      PRIORIDADES      ITENS  
      1      PARÊNTESES   E FUNÇÕES  
      2      EXPRESSÕES   ARITMÉTICAS  
      3      RELAÇÕES  
      4      NÃO  
      5      E  
      6      OU  

   Funções
As funções são algoritmos pré-definidos que irão retornar valores normalmente resultantes de&nbsp; operações aritméticas.Estas funções têm por finalidade agilizar o desenvolvimento dos nossos algoritmos, já que os procedimentos para calculo destas funções não são de grande importância.Mais tarde estudaremos mais a fundo as funções , por hora basta saber como elas são utilizadas em nossos algoritmos.
São elas:
  
      FUNÇÃO      RETORNO  
      SQR   ( P )      RAIZ   QUADRADA DE P  
      ABS   ( P )      VALOR   ABSOLUTO DE P  
      TRUNCA   ( P )      PARTE   INTEIRA DE P  
      ARREDONDA(   P )      INTEIRO   MAIS PROXIMO DE P  
      EXP   ( P )      FUNÇÕES   EXPONENCIAL DE P  
      QUOC ( P,Q )      QUOEFICIENTE   INTEIRO DE P POR Q  
      RESTO   ( P,Q )      RESTO   DA DIVISÃO INTEIRA DE P POR Q  
      LOG   ( P )      LOGARITMO   NA BASE 10 DE P  
      LN   ( P )      LOGARITMO   NEPERIANO DE P   

   
Comando de Atribuição.
É o comando usado para atribuir um valor a uma variável.A natureza deste valor deve ser compatível com o tipo da variável declarada.O sinal utilizado para indicar uma atribuição é o : = (dois pontos igual)É importante neste ponto esclarecer com é que funciona o processo de atribuição:Caso eu esteja atribuindo para uma variável o resultado de uma expressão, o algoritmo primeiro deverá resolver a expressão para depois fazer a atribuição.Exemplo
A: = 3 + (2 * 6)MOSTRE ( A )&nbsp; {RESULTADO 15}
O resultado deste comando será 15, porque o algoritmo primeiro resolve a expressão e depois guardou o valor conseguido na variável especificada (A).Também podem ser utilizados os valores armazenados em outras variáveis, para se fazer uma atribuição:
A: = 5B : = 3C: = (A + B) / 2MOSTRE (C) {RESULTADO 4}
No final desta seqüência de comandos o valor dentro da variável c será 4, pois o algoritmo utilizou o valor das variáveis A e B para calculara o valor da expressão e depois o armazenou em C.Também pode ser utilizado o valor da própria variável que receberá a atribuição:
A: = 7B: = 5C : =9C: = (A + B + C) / 3MOSTRE (C) {RESULTADO 7}
No final desta seqüência o valor de C será&nbsp; 7 , pois o algoritmo primeiro utiliza o valor 9 armazenado em C para resolver a expressão, e depois de resolvida , o novo valor será armazenado em C , apagando o valor anterior.Isto fica mais claro no exemplo abaixo:
CONTADOR : = 1CONTADOR : = CONTADOR + 1MOSTRE (CONTADOR) { RESULTADO 2}
A variável CONTADOR&nbsp; foi inicializada com o valor 1 , e logo abaixo este valor foi utilizado em uma expressão, e o resultado desta expressão foi&nbsp; armazenado dentro da própria variável CONTADOR. Mas é importante notar que o algoritmo primeiro utilizou o valor 1 para resolver a expressão , e somente após ter a resposta é que ele alterou o valor da variável CONTADOR.Na verdade eu apenas somei 1 ao valor que já existia na variável.   

Comandos de Entrada E Saída 
Um comando de entrada permite a entrada de dados do meio externo para o computador, e um comando de saída permite a saída de dados do computador para o meio externo. 
São eles:
Comando Leia
Permite que o usuário entre com um valor , que será armazenado em uma variável e poderá ser utilizado pelo algoritmo.O comando Leia interrompe a execução do algoritmo até que o usuário digite o valor solicitado, quando então, armazena este valor na variável especificada no comando e dá proceguimento a execução do Algoritmo.O comando Leia não permite que se faça uma critica dos valores digitados, por isso, se for necessário esta critica , ela deverá ser implementada no próprio algoritmo.A nível &nbsp;de Algoritmo, não será necessário implementar este tipo de critica.
Sintaxe:
Leia (Variável)
Onde:<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Variável é o nome da variável aonde o valor digitado pelo usuário será armazenado. Note que o valor digitado deverá ser do mesmo tipo da variável.
Comando Mostre:
O comando Mostre permite que sejam mostrados para o usuário os valores armazenados em variáveis ou então expressões literais.Uma vez que o algoritmo tenha cumprido as suas funções, o comando Mostre é a forma de mostrar ao usuário os resultados do processamento.Alem disso, o comando Mostre também pode ser utilizado para mostrar mensagens que ajudaram o usuário na utilização do algoritmo.
Sintaxe:
Mostre (Variável)Mostre (Expressão Literal)
Onde:Variável é o nome da variável cujo valor se deseja mostrarExpressão Liretal é uma frase ou expressão que se deseja mostra para o usuário. Ela deve estar entre Aspas (““)   
Expressões Literais
As expressões literais são frases ou outro tipo de expressões que são colocadas no algoritmo com mensagens ou para atribuição em variáveis do tipo STRING ou CHAR. Estas expressões são identificadas por estarem entre aspas ( " "&nbsp; ).É importante notar que nada impede que um numero seja colocado dentro de uma expressão literal, ou em uma variável STRING ou CHAR, mas note que este tipo de numero não vai possuir o valor numérico, ou seja, este numero não vai poder ser usado para realizar operações aritméticas. Para este caso nós devemos utilizar números armazenados em variáveis do tipo inteiro ou real.
Exemplo:
INICIONUM : INTEIROX : STRING [ 6 ]PROCEDANUM: = 999999X : = "999999"NUM : = NUM + 1MOSTRE (NUM)&nbsp;&nbsp;&nbsp;&nbsp; { RESULTADO&nbsp; IGUAL&nbsp; A 1000000}X: = X + 1&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; { ESTE COMANDO É INVALIDO JÁ QUE X É DO TIPO STRING}MOSTRE (X)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {RESULTADO IGUAL A "999999"} FIM
Note que no exemplo acima eu declarei 2 variáveis, uma do tipo INTEIRO&nbsp; e outra do tipo STRING, e que eu atribui para ambas o valor 999999, mas no caso da variável&nbsp; do tipo STRING eu usei as aspas para indicar que este valor é uma expressão literal, e que por isso não tem valor numérico. Este tipo de expressão é muito útil no caso de termos que armazenar informações como endereço ou telefones, que exigem a presença de números e letras.No caso da variável do tipo INTEIRO o valor 999999 foi atribuído sem as aspas, já que a eu estou utilizando o valor numérico, e poderei usar este numero em qualquer operação aritmética.   
Estruturas de Controle.
São as formas como serão executados os comandos do algoritmo, são elas.
Estrutura Seqüencial
É a mais simples, eficiente e legível das estruturas de controle.Estabelece que uma declaração passa a ser analisada imediatamente após o termino de sua predecessora.Um algoritmo se inicia com a palavra INICIO, após o que, aparecem as declarações de variáveis, seguidas de comandos que, se não houverem indicações ao contrario , serão executados um depois do outro em seqüência.A finalização do algoritmo é feita com a palavra FIM.
Exemplo
INICIOA,B : INTEIROMEDIA : REALPROCEDA MEDIA {CALCULO DA MEDIA ENTRE 2 NUMEROS}LEIA ( A )LEIA ( B )MEDIA : = (A + B ) / 2MOSTRE&nbsp; ( MEDIA )FIM.   
Estruturas de Seleção
São usadas quando é necessário fazer uma opção entre 2 ou mais caminhos sendo que o fluxo do algoritmo é desviado segundo uma condição lógico relacional.Esta estrutura subordina a execução de um comando, ou bloco de comandos, a veracidade ou não de uma condição lógico relacional.Os comandos utilizados para implementar &nbsp;a estrutura de seleção são :
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp; SE<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->SE SENÂO<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp; CASO
Comando SE
O comando SE especifica se um comando, ou um conjunto de comando será ou não executado, de acordo com uma &nbsp;condição lógico relacional. 
Sintaxe:SE&nbsp;&nbsp; &lt;CONDIÇÃO&gt;<!--[if gte vml 1]><v:shape id="_x0000_i1026" type="#_x0000_t75"
 style='width:92.25pt;height:68.25pt' o:ole="">  <v:imagedata src="file:///C:\Users\ITALO-~1\AppData\Local\Temp\msohtmlclip1\01\clip_image003.wmz"
  o:title=""/> <![endif]--><!--[if !vml]--><!--[endif]--><!--[if gte mso 9]>  <o:OLEObject Type="Embed" ProgID="MSDraw" ShapeID="_x0000_i1026"
  DrawAspect="Content" ObjectID="_1376409072">   <![endif]-->&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;FIM_SE
O comando SE acima especifica que o bloco de comandos que esta entre o inicio do comando até a palavra FIM_SE somente será executado se&nbsp; &lt;CONDIÇÃO&gt;&nbsp; for verdadeira, caso a condição for falsa, o algoritmo vai prosseguir normalmente após a palavra FIM_SE.   
Comando SE SENÂO
O comando SE ainda permite que seja associado a ele um segunda opção, o comando SENÃO.O comando senão pode ou não ser associado ao comando SE, uma vez associado, ele especifica que os comandos a ele subordinados só serão executado no caso da condição lógico relaciona for falsa, ou seja, só será executado caso os comandos associados ao comando SE não forem executados.
Sintaxe:
SE &lt; CONDIÇÃO &gt;<!--[if gte vml 1]><v:shape
 id="_x0000_i1027" type="#_x0000_t75" style='width:87.75pt;height:86.25pt'
 o:ole="">  <v:imagedata src="file:///C:\Users\ITALO-~1\AppData\Local\Temp\msohtmlclip1\01\clip_image005.wmz"
  o:title=""/> <![endif]--><!--[if !vml]--><!--[endif]--><!--[if gte mso 9]>  <o:OLEObject Type="Embed" ProgID="MSDraw" ShapeID="_x0000_i1027"
  DrawAspect="Content" ObjectID="_1376409075">   <![endif]-->&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;SENÃO<!--[if gte vml 1]><v:shape
 id="_x0000_i1028" type="#_x0000_t75" style='width:87.75pt;height:86.25pt'
 o:ole="">  <v:imagedata src="file:///C:\Users\ITALO-~1\AppData\Local\Temp\msohtmlclip1\01\clip_image007.wmz"
  o:title=""/> <![endif]--><!--[if !vml]--><!--[endif]--><!--[if gte mso 9]>  <o:OLEObject Type="Embed" ProgID="MSDraw" ShapeID="_x0000_i1028"
  DrawAspect="Content" ObjectID="_1376409078">   <![endif]-->&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; FIM_SENo comando acima, o bloco de comandos A só será executado no caso da condição lógico relaciona for verdadeira, e o bloco de comando B só será executado no caso da condição lógico relacional for falsa. De qualquer forma, após executar tanto o bloco A como o bloco B o algoritmo seguirá normalmente a partir da palavra FIM_SE.   
Comando CASO
É o comando que permite a opção entre várias alternativas de acordo com a verificação de uma condição lógico relacional.
Sintaxe:
CASOMES = 1SALARIO : = SALARIO * 1.53MES = 2SALARIO : = SALARIO * 1.72MES = 3 SALARIO : = SALARIO * 1.83FIM_CASO.
Note que no comando CASO, a mesma variável será testada com várias condições, caso uma delas seja atendida, o comando, ou bloco de comandos associados a esta condição será executado, e logo após o algoritmo seguirá normalmente após a palavra FIM_CASO.No caso de nenhuma condição ser verdadeira, o algoritmo seguirá normalmente após a palavra FIM_CASO sem executar nenhum comando associado ao comando CASO.O comando Caso é Equivalente a uma sequancia de comando SE SENÂO
Embutimento
Uma estrutura se seleção pode ter uma outra estrutura de seleção dentro dela, e assim por diante. Neste caso nós podemos colocar um comando SE subordinado a outro comando SE, ou um comando SE subordinado a um comando CASO , ou vice e versa, sem limite de encadeamento.
É importante ressaltar que para formação das condições dos comandos de seleção serão utilizados operadores relacionais associados ou não a operadores lógicos.
   Exercicio 02:
Monte as estruturas de seleção necessárias para representar as seguintes situações:
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Clientes regulares que adquirirem mais de 1 Milhão e que tem um bom histórico de pagamento ou que estão conosco a mais de 20 anos devem receber tratamento especial caso contrario tratamento normal.<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->O subsidio de um escoteiro Lobinho pode variar de acordo com o posto e com o tempo de associado da seguinte forma:
O subsidio para membros a um ano é de 25 Reais, de 35 reais para membros a dois anos, e de 50 reais para membros a&nbsp; mais de 2 anos, alem disso cada escoteiro recebe um subsidio extra de 10 reais de obteve o posto de Lobo, 20 reais de obteve o posto de Urso, e 20 reais de obteve o posto de Leão.<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Uma Loja da Cidade esta oferecendo aos seus clientes as seguintes promoções:<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Pagamento a vista 50% de desconto<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Pagamento em cheque 40% de desconto<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Pagamento com cheque pré datado 30 dias(20%)<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Pagamento com cheque pré datado 30 e 60 dias(10%)<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Pagamento com cheque pré datado 30 60 e 90 dias(5%)<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Cartão de Credito 30% de desconto<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Alem disso cliente cadastrado tem um desconto de 5% adicional<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Suponha que o Professor de Educação física&nbsp; nos pediu para pesquisar os registros dos alunos e produzir uma lista com o nome e endereço de todos os alunos e o esporte indicado para eles de acordo com as seguintes condições:Sexo masculino com mais de 1,80 metros de      altura=&gt; Basquete
Sexo masculino entre 1,70 e 1,80=&gt; Voleibol
Sexo feminino com mais de&nbsp;      1,70&nbsp; =&gt; Basquete
Sexo feminino entre 1,50 e&nbsp;      1,70 =&gt; Voley 
Ambos os sexos com menos de 1,50 =&gt; natação

   
Estruturas de Repetição
São usadas sempre que for necessário repetir um conjunto de declarações para manter a abstração de controle do algoritmo .São as mais complicadas, e as que exigem o maior cuidado na sua escolha e aplicação.
Comando ENQUANTO.
Prescreve que os comandos a ele subordinados deverão ser repetidos ENQUANTO&nbsp; uma condição lógico relacional for verdadeira. O teste é feito no inicio do comando , e caso o resultado for verdadeiro os comandos serão executados , logo em seguida outro teste será feito. Caso o teste seja falso, o algoritmo continua normalmente após a palavra FIM_ENQUANTO.Note que se o primeiro teste de falso , os comando não serão executados nenhuma vez, e o algoritmo continuará normalmente após a palavra FIM_ENQUANTO.
Sintaxe:
<!--[if gte vml 1]><v:shape
 id="_x0000_i1029" type="#_x0000_t75" style='width:254.25pt;height:206.25pt'
 o:ole="">  <v:imagedata src="file:///C:\Users\ITALO-~1\AppData\Local\Temp\msohtmlclip1\01\clip_image009.wmz"
  o:title=""/> <![endif]--><!--[if !vml]--><!--[endif]--><!--[if gte mso 9]>  <o:OLEObject Type="Embed" ProgID="MSDraw" ShapeID="_x0000_i1029"
  DrawAspect="Content" ObjectID="_1376409081">   <![endif]-->&nbsp;
Exercício 03:
Faça um algoritmo capaz de&nbsp; somar todos os números inteiros compreendidos entre 1 e 10, e mostrar o resultado da soma.INICIOSOMA,CONT : INTEIROSPROCEDA SOMACONT : = 1SOMA : = 0ENQUANTO CONT &lt; = 10SOMA : = SOMA + CONTCONT : = CONT + 1FIM_ENQUANTOMOSTRE ( SOMA)FIM.   
Comando REPITA.
Prescreve que os procedimentos a ele subordinados deverão ser repetidos ATÉ&nbsp; que uma condição lógico relacional seja verdadeira.O teste será feito no final do comando, e caso seja FALSO , os comando que estão entre o REPITA , e o FIM_REPITA ,serão repetidos, e novamente será feito um teste. Quando o resultado do teste for verdadeiro, o algoritmo continua normalmente a partir da palavra FIM_REPITA.Note que sendo o teste feito no final do comando, os comando subordinados ao repita serão executados pelo menos uma vez.
Sintaxe:
<!--[if gte vml 1]><v:shape
 id="_x0000_i1030" type="#_x0000_t75" style='width:222.75pt;height:159.75pt'
 o:ole="">  <v:imagedata src="file:///C:\Users\ITALO-~1\AppData\Local\Temp\msohtmlclip1\01\clip_image011.wmz"
  o:title=""/> <![endif]--><!--[if !vml]--><!--[endif]--><!--[if gte mso 9]>  <o:OLEObject Type="Embed" ProgID="MSDraw" ShapeID="_x0000_i1030"
  DrawAspect="Content" ObjectID="_1376409084">   <![endif]-->
Exercício 04:
Idem ao execicío 03 só que utilizando o comando REPITA.
INICIOSOMA,CONT : INTEIROPROCEDA SOMACONT: = 1SOMA : = 0REPITASOMA : = SOMA + CONTCONT : = CONT + 1ATE CONT &gt; 10FIM_REPITAMOSTRE ( SOMA)FIM.   
Comando PARA
O comando PARA prescreve que os comandos a ele subordinados deverão ser repetidos , a partir de uma variável&nbsp; "I", inicializada pelo comando, com um incremento "J" , até que uma condição lógico relacional seja verdadeira.O teste será feito no inicio dos procedimentos, sendo que se na primeira comparação o resultado for verdadeiro os procedimentos não serão executados nenhuma vez.A diferença do comando PARA&nbsp; em relação aos outros, é que ele automaticamente incremente uma variável de controle, sendo que esta variável de controle deverá ser utilizada na formação da condição de parada do comando. O comando PARA é recomendado para situações aonde nos tenhamos um numero fixo de interações, e que sejam necessários incrementos fixo.
Sintaxe:
<!--[if gte vml 1]><v:shape
 id="_x0000_i1031" type="#_x0000_t75" style='width:302.25pt;height:3in' o:ole="">  <v:imagedata src="file:///C:\Users\ITALO-~1\AppData\Local\Temp\msohtmlclip1\01\clip_image013.wmz"
  o:title=""/> <![endif]--><!--[if !vml]--><!--[endif]--><!--[if gte mso 9]>  <o:OLEObject Type="Embed" ProgID="MSDraw" ShapeID="_x0000_i1031"
  DrawAspect="Content" ObjectID="_1376409087">   <![endif]-->Exercício 05
Idem ao exercicio 03 só que utilizando o comando PARA
INICIOSOMA, CONT : INTEIROPROCEDA SOMASOMA : = 0PARA CONT : = 1INCREMENTO = 1ATE CONTA &gt; 10SOMA : = SOMA + CONTFIM_PARAMOSTRE ( SOMA)FIM_PARA   
Regras para Codificação de Algoritmos.
1.&nbsp;&nbsp; FAÇA O ALGORITMO CERTO NA PRIMEIRA VEZ2.&nbsp;&nbsp; NOMES DEVEM SE ASSEMELHAR AQUILO QUE REPRESENTAM3.&nbsp;&nbsp; TODO ALGORITMO DEVE , A PARTIR DE UMA ESTRUTURA SIMPLES E FÁCIL , DAR UMA RESPOSTA ADEQUADA AO PROBLEMA QUE SE PROPÕEM4.&nbsp;&nbsp; RESPEITE A ESTÉTICA, ESTRUTURAS SUBORDINADAS DEVEM SER ENDENTADAS5.&nbsp;&nbsp; NUNCA ESQUEÇA A PRIMEIRA REGRA.
Regras para Declaração de Variáveis:
Umas das coisas mais difíceis de se fazer quando esta esta no inicio do aprendizado de algoritmos é decidir quais as variaves serão necessárias para o funcionamento de algoritmo.Seguem algumas resgras que poderão ajudar neste problema.
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->O usuário vai informar alguma coisa para o algoritmo?
Então se deve declarar uma variavel para armazenar cada valor que sera informado pelo usuário.<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->O algoritmo vai realizar algum calculo?
Então deveremos criar uma variavel para armazenar o resultado de cada calculo.<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->O algoritmo vai ter estruturas de repetição?
Então devemos declarar uma variável para controlar esta estrutura de repetição.
È claro que estas regras não cobrem todos os casos, mas servirão para ajudar no inicio do aprendizado.   
Exercícios
Exercício 06:
Faça um algoritmo para Somar todos os numero inteiros compreendidos entre 2 numero, sendo que:
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Os dois numeros serão informados pelo usuário<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O numero inicial não poderá ser maior&nbsp; ou igual ao numero final
INICIOSOMA: INTEIRO {VARIAVEL PARA ARMAZENAR A SOMA DOS NUMEROS}NUMERO_INICIAL : INTEIRO { PARA LEITURA DO NUMERO INICIAL DA SEQÜÊNCIA}NUMERO_FINAL : INTEIRO {PARA LEITURA DO NUMERO FINAL DA SEQÜÊNCIA}CONT: INTEIRO { VARIÁVEL DE CONTROLE DO LOOP}PROCEDA CALCULA_SOMAREPITALEIA ( NUMERO_INICIAL)&nbsp;&nbsp;&nbsp; {USUÁRIO INFORMA OS NÚMEROS}LEIA (NUMERO_FINAL)SE NUMERO_INICIAL &gt; = NUMERO_FINALMOSTRE ( "NÚMEROS INVÁLIDOS " )&nbsp; { NÚMEROS INVÁLIDOS}FIM_SEATE NUMERO_INICIAL&nbsp; &lt;&nbsp; NUMERO_FINAL {VAI REPETIR ATE NUMERO SEJAM VÁLIDOS}SOMA : = 0PARA CONT : = NUMERO_INICIALINCREMENTO = 1ATE CONTA CONT &gt; NUMERO_FINALSOMA : = SOMA + CONT&nbsp;&nbsp;&nbsp; {CALCULO DA SOMA}FIM_PARAMOSTRE ( SOMA) { MOSTRA OS RESULTADOS}.FIM.   
Exercício 07:
Sendo a formula de uma equação do segundo grau:
X = (-B <!--[if supportFields]><span style='font-size:12.0pt;mso-bidi-font-size:
10.0pt'>SYMBOL 177 \f &quot;Symbol&quot;<![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]--> SQR(&nbsp; B2 - 4*A*C )) / 2*A
Desenvolver um algoritmo capaz de calcular as raízes de uma equação sendo que:
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Os valores A , B , C serão informados pelo usuário.<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->O Valor de a não pode ser Zero<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O algoritmo deve informar caso não existam raízes reais.
INICIOA , B , C , DELTA , X1 , X2 : REALPROCEDA EQUAÇÃOLEIA (A)SE A = 0 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; MOSTRE(“ESTE VALOR NÃO PODE SER ZERO”)SENÃOLEIA (B)&nbsp;&nbsp;&nbsp;&nbsp; {USUÁRIO INFORMA OS VALORES A,B,C}LEIA (C)DELTA : = B <!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 173 \f &quot;Symbol&quot;<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]--> 2&nbsp; - ( 4 * A * C )SE DELTA &lt; 0 MOSTRE ( "NÃO EXISTEM RAIZES PARA ESTE VALORES")SENÃOX1 : = (( - B + SQR (DELTA)) / ( 2*A))X2 : = (( - B -&nbsp; SQR (DELTA)) / (2*A))&nbsp;&nbsp; {CALCULO DAS RAIZES}MOSTRE (X1) MOSTRE (X2)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {INFORMA OS RESULTADOS}FIM_SEFIM-SEFIM.
   
Exercício 08:

Desenvolver um algoritmo capaz de calcular a media aritmética simples de uma série de números , sendo que:
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O usuário deve informar a quantidade de números da série.<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Se a quantidade for zero ou negativa o algoritmo não deve aceita-la.<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O usuário deve informar um por um todos os números da série.<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O algoritmo deve mostrar como resultado a media aritmética simples calculada através da&nbsp; formula:MEDIA = (X + X1 + X2+...XN) / N.
INICIOSOMA: INTEIRO {PARA ARMAZENAR A SOMA DE TODOS OS NÚMEROS DIGITADOS}NUM : INTEIRO {PARA LEITURA DE CADA NUMERO INFORMADO}N:&nbsp; INTEIRO {A QUANTIDADE DE NÚMEROS DA SÉRIE}MEDIA : REAL {PARA O CALCULO DA MÉDIA}PROCEDALEIA ( N )&nbsp; { QUANTIDADE DE NÚMEROS DA SÉRIE}SE N &lt; = 0MOSTRE ( "NUMERO NEGATIVO")SENAOCONT : = 1SOMA: = 0ENQUANTO CONT &lt; =&nbsp; NLEIA (NUM)SOMA : = SOMA + NUM&nbsp; {CALCULO DA MÉDIA}FIM_ENQUANTOMEDIA : = SOMA / NMOSTRE (MEDIA)FIM_SEFIM.   
Exercício 09

Desenvolver um algoritmo capaz de calcular o fatorial de um numero inteiro positivo informado pelo usuário, sendo que:
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O numero para o calculo deve ser informado pelo usuário<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O algoritmo deve informar o fatorial deste numero de acordo com as regras abaixo:<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O fatorial de numero negativos não existe<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O fatorial de 0 é 1<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O fatorial de 1 é 1<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O fatorial de um numero qualquer é da do pela seguinte formula:5! = 5*4*3*2*14! = 4*3*2*1N! = N * (N-1) * (N-2)...* 1
INICIONUM:&nbsp;&nbsp; INTEIRO {PARA LEITURA DO NUMERO}FATORIAL : INTEIRO {PARA O CALCULO DO FATORIAL}PROCEDA FATORIALLEIA (NUM)SE NUM &lt; 0 MOSTRE (“NUMERO INVÁLIDO”) SENAOFATORIAL : = 1ENQUANTO NUM &gt; 0FATORIAL : = FATORIAL * NUMNUM: = NUM - 1FIM_ENQUANTOMOSTRE (FATORIAL)FIM_SEFIM.   
Exercício 10

Escreva um algoritmo para calcular os números harmônicos sendo que
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O usuário deve informar o numero para o calculo<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O numero informado deverá ser maior que 0<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O calculo do numero harmônico é feito da seguinte forma:<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; 5H = 1 + (1/2) + (1/3)+ (1/4)+(1/5)<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; NH= 1+(1/2) + (1/3) ... (1/N)
INICIONUM: INTEIRO {PARA INFORMAR O NUMERO PARA CALCULO}HARMONICO: REAL {PARA CALCULO DO HARMONICO}PROCEDALEIA (NUM)SE NUM &lt; = 0MOSTRE (“NUMERO INVALIDO")SENÃOHARMONICO : = 0ENQUANTO NUM &gt; = 1HARMONICO : = HARMONICO + (1 / NUM)NUM : = NUM - 1FIM_ENQUANTOMOSTRE (HARMONICO)FIM_SEFIM.   
Exercício 11

Escreva um algoritmo capaz de calcular a seqüência de fibonacci sendo que:
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O primeiro&nbsp; numero é sempre 0<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O segundo numero é sempre 1<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Os próximos números são o resultado da soma de seus dois predecessores.
Exemplo:
0,1,1,2,3,5,8,13,21,34,55,89...
O algoritmo deve calcular e mostrar a seqüência de fibonacci ate que o ultimo numero calculado seja maior ou igual a um limite que será informado pelo usuário.
INICIONUM:INTEIROFIBONACCI:INTERIOULTIMO : INTEIROPENULTIMO:INTEIROCONT:INTEIROPROCEDALEIA (NUM)SE NUM &lt; = 0MOSTRE ("NÃO EXISTE SEQUENCIA DE FIBONACCI")SENÃOPENULTIMO : = 0ULTIMO: =1MOSTRE (PENULTIMO)MOSTRE (ULTIMO)FIBONACCI : = ULTIMO + PENULTIMOENQUANTO FIBONACCI &lt; NUMEROMOSTRE (FIBONACCI)PENULTIMO : = ULTIMOULTIMO : = FIBONACCIFIBONACCI : = ULTIMO + PENULTIMOFIM_ENQUANTOMOSTRE (FIBONACCI)FIM_SEFIM.   Exercício 12
Faça um algoritmo capaz de determinar o maior número de uma seqüência de 10 números que deverão ser digitados pelo usuário , e apresente o resultado ao final do processamento.
   Exercício 13
Faça um algoritmo capaz de calcular a media das notas de dez alunos que deverão ser informadas pelo usuário, e após o calculo informe o número de alunos que ficou com a nota acima da media calculada.INICIONOTAS : MATRIZ [ 10 ] DE REALSOMA: REALMEDIA: REALCONT:INTEIROACIMA:INTEIROPROCEDA MEDIA_10MOSTRE (“DIGITE AS 10 MEDIAS”)CONT: =1SOMA : = 0ENQUANTO CONT &lt; = 10LEIA (NOTAS [ CONT ] )SOMA: = SOMA + NOTAS[CONT]FIM_ENQUANTOMEDIA : = (SOMA / 10)ACIMA:=0CONT : =1ENQUANTO CONT &lt; = 10SE NOTAS [ CONT ] &gt; MEDIAACIMA : = ACIMA +1FIM_SEFIM_ENQUANTOMOSTRE (“ A MEDIA DAS NOTAS FOI=&gt;”)MOSTRE (MEDIA)MOSTRE( “ QUANTIDADE DE NOTAS ACIMA DA MEDIA”)MOSTRE (ACIMA)FIM.
   Exercício 14
Uma empresa de autopeças classifica os seus funcionários da seguinte forma:
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Funcionário Classe A: É aquele que produziu até 100 pecas por mês<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Funcionário classe B: é Aquele que produziu de 101 a 200 Pecas por mês<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Funcionário classe C: é aquele que produziu mais de 201 pecas em um mês 
Sendo ainda que o salário dos funcionários é calculado da seguinte forma:
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Classe A : Um salário mínimo por mês<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Classe B : Um salário mínimo mais 10 centavos por peca produzida acima de 101 pecas<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Classe C : um salário mínimo mais 15 centavos por peca produzida acima de 101 pecas e 20 centavos por peca produzida acima de 201 pecas.
Faca um algoritmo que permita a digitação de 10 nomes de funcionários, e as suas respectivas&nbsp; quantidades de pecas produzidas no mês, e que após o ultimo funcionário tenha sido digitado, o algoritmo deverá informar a quantidade de funcionários de cada classe, a produção total de todos os funcionários, e o total de salário pago pela empresa para todos os funcionários.
   
Matrizes

Uma matriz é um tipo de dado homogêneo, que suporta a manipulação de qualquer tipo de dado primitivo, desde que seja apenas um tipo. A matriz é uma estrutura de dados dividida em linhas e colunas. Desta forma nós podemos armazenar dentro dela diversos valores ,sendo que para podermos especificar um destes valores&nbsp; devemos identifica-lo através do numero da linha e da coluna aonde o elemento de encontra.Como se pode perceber, dependendo do numero de colunas e linha de uma matriz, ele pode conter uma infinidade de informações, dai a necessidade de se especificar a linha e a coluna em que se encontram os elementos para que ele possa ser identificado.Exemplo:  
      
      1      2      3  
      1      C      F      E  
      2      D      A      B  
      3      H      G      I  
      4      L      M      J  

Desta forma, cada elemento armazenado na matriz poderá ser acessado através do cruzamento de sua respectiva linha com a sua coluna.Exemplo :Na matriz acima nós temos os valores A,B,C,D,E,F,G,H,I,J,L,M, todos eles armazenados na mesma estrutura. Para que possamos acessar um item especifico qualquer nós devemos informar o numero da linha e coluna.Para acessar uma letra especifica deveremos faze-lo da seguinte forma: 
MATRIZ [ 2 , 2 ] =&gt; A MATRIZ [ 1 , 3 ] =&gt; HMATRIZ [ 3 , 1 ] =&gt; E
Note que eu sempre devo especificar primeiramente a COLUNA,&nbsp; e&nbsp; depois&nbsp; LINHA.   Algoritmos de Manipulação de Matrizes.
Exercício 15:
Dada uma matriz 4 x 4&nbsp; de inteiros&nbsp; faça um algoritmo que permita o preenchimento de toda a matriz com os valores digitados pelo usuário.
   Exercício 16:
Dada a matriz 4x4 preenchida no exercício anterior , faça um algoritmo capaz de fazer a soma de todos os valores de cada coluna e apresente o resultado na tela.
   Exercício 17:
Escreva um algoritmo capaz de calcular a soma dos elementos que se encontram abaixo da diagonal principal de uma matriz de 10x10 do tipo inteiro, que deverá ser digitada pelo usuário , e apresentar o resultado no final do processamento.
   Exercício 18:
Faça um algoritmo capaz de somar todos os valores de uma mesma linha de todas as linhas de uma matriz 4X5 do tipo inteiro, que deverá ser digitadas pelo usuário , e apresentar o resultado da soma de cada linha para o usuário   Exercício 19:
Dada uma matriz de 4x4 do tipo inteiro que deverá ser preenchida pelo usuário, faca um algoritmo capaz de criar uma nova matriz com as mesmas dimensões , baseada na primeira cujos elementos deve obedecer as seguintes regras:
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Quando o número da coluna for maior que o número da linha, o elemento deverá ser multiplicado pelo valor da coluna e colocado ma mesma posição na nova matriz
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Quando o número da linha for maior que o da coluna, o elemento deverá ser multiplicado pelo número da linha e colocado na mesma posição na nova matriz.
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Quando o número da coluna for igual ao da linha, o elemento devera ser multiplicado por 10 e colocado na mesma posição na nova matriz.
Após o processamento o algoritmo deverá mostra a nova matriz elemento a elemento para o usuário.


   
Exercício 20:
Quadrado Mágico.
  
      15      15      15      15      15  
      15      6      1      8      15  
      15      7      5      3      15  
      15      2      9      4      15  
      15      15      15      15      15  


Fazer um algoritmo capaz de colocar em uma matriz quadrada (aonde a quantidade de linhas é igual a quantidade de colunas) números inteiros, começando pelo&nbsp; 1 até o ultimo numero inteiro necessário para preencher todas as casas da matriz (sem pular nenhum), de forma que a soma de todos os elementos de uma linha qualquer seja igual a soma de todos os elementos de uma coluna qualquer, inclusive também deverá ser igual a soma das diagonais da matriz.
REGRAS:
1.&nbsp;&nbsp; Aceitar a ordem da matriz.(deve ser ímpar)2.&nbsp;&nbsp; O primeiro numero é colocado na primeira linha e na coluna central3.&nbsp;&nbsp; Repetir até&nbsp; que o ultimo numero colocado seja maior que o quebrado de ordem da matriz:<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Subtrair 1 da coluna<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Subtrair 1 da linha<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Se&nbsp; a linha for&nbsp; igual a zero então a linha passa a ser a ordem da matriz<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Se a coluna for igual a zero então a coluna passa a ser a ordem da matriz<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Se a posição estiver ocupada<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; A linha passa a ser igual a linha anterior +1<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; A coluna passa a ser a coluna anterior

   INICIOARGUMENTOORDEM {ORDEM DO QUADRADO MAGICO}VARIAVEISORDEM:INTEIROQUADRADO:MATRIZ [ORDEM , ORDEM] {MATRIZ P/ ARMAZENAR O}&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {QUADRADO MAGICO}LINHA:INTEIRO&nbsp;&nbsp;&nbsp;&nbsp; {CONTADOR DE LINHA DA MATRIZ}COLUNA:INTEIRO {CONTADOR DE COLUNAS DA MATRIZ}LINHA_ANTERIOR:INTEIRO&nbsp;&nbsp;&nbsp;&nbsp; {ARMAZENAR A LINHA ANTERIOR}COLUNA_ANTERIOR:INTEIRO {ARMAZENAR A COLUNAANTERIOR}CONT:INTEIROPROCEDA QUADRADO_MAGICOSE RESTO(ORDEM / 2) = 0 MOSTRE ( "ORDEM INVALIDA PARA QUADRADO MAGICO")SENAOCONT : = 1LINHA : = 1COLUNA : = (ORDEM +1) / 2QUADRADO [ COLUNA , LINHA ] : = CONTENQUANTO CONT &lt;= ORDEM * ORDEM LINHA : = LINHA - 1COLUNA : = COLUNA - 1CONT : = CONT + 1SE LINHA = 0 LINHA : = ORDEMFIM_SESE COLUNA : = 0COLUNA : = ORDEMFIM_SESE QUADRADO [ COLUNA , LINHA ]&nbsp; &lt; &gt; NULOLINHA : = LINHA ANTERIOR + 1COLUNA : = COLUNA_ANTERIORFIM_SEQUADRADO [ COLUNA , LINHA ] : = CONTADORLINHA_ANTERIOR : = LINHACOLUNA_ANTERIOR : = COLUNAFIM_ENQUANTOFIM_SEFIM.   
Vetores:
Existem também as chamadas matrizes unidimensionais, ou vetores. Neste caso a matriz será formada apenas por linhas ou colunas, sendo necessário informar apenas 1 numero para identificar um elemento dentro da matriz.
EXEMPLO:     
  
      
      1  
      1      A  
      2      B  
      3      C  
      4      D  
   No exemplo ao lado a matriz tem apenas uma coluna, e poderia ser declarada da seguinte forma:LETRAS:MATRIZ[4] DE CHARE cada elemento poderá ser identificado da seguinte forma:LETRAS[3]: = "C"       
Algoritmos de Manipulação de Vetores.
Exercício 21:
Dada um vetor de 10 posições do tipo&nbsp; inteiro,&nbsp; faça um algoritmo que permita o preenchimento de toda o vetor com os valores digitados pelo usuário.
INICIO VARIAVEIS;NUMEROS:MATRIZ [10 ] DE INTEIROS;POS: INTEIRO;{CONTADOR DEPOSIÇÃO DO VETOR}PROCEDA PARA POS : = 1 INCREMENTO = 1ATE POS&nbsp; &gt; 10LEIA ( NUMEROS [POS ] )FIM_PARAFIM.   
Exercício 22
Dado o vetor de 10 posições do tipo inteiro preenchido no exercício anterior , faça um algoritmo capaz de fazer a soma de todos os seus valores e apresente o resultado na tela.
INICIO VARIAVEIS;NUMEROS : MATRIZ [10 ] DE INTEIROS;POS:INTEIRO {CONTADOR DA POSICAO NO VETOR}SOMA:INTEIRO;{VARIAVEL PARA ARMAZENAR A SOMA DOS VALORES}&nbsp;PROCEDA SOMA: = 0;PARA POS : = 1 INCREMENTO = 1ATE POS&nbsp; &gt;&nbsp;&nbsp; 10SOMA : = SOMA + NUMEROS [POS ]FIM_PARAMOSTRE ( "O RESULTADO DA COLUNA =&gt; ")MOSTRE ( SOMA )FIM.   
Exercício 23
Dado o vetor do exercício anterior faca um algoritmo capaz de dobrar os valores de todas as posições do vetor.
INICIO VARIAVEIS;NUMEROS : MATRIZ [ 4 , 4 ] DE INTEIROS { MATRIZ ORIGINAL}POS:INTEIRO {CONTADOR POSICAO}PROCEDAPARA POS : = 1 INCREMENTO = 1ATE POS &gt; 10NUMEROS [ POS ] : = NUMEROS [ POS ] * 2FIM_PARA FIM.   
Exercício 24
Dado o vetor do exercício anterior faça um algoritmo para mostrar na tela somente os valores que estiverem em posições impares dentro do vetor.
INICIO NUMEROS : MATRIZ [ 10 ] DE INTEIROS {DECLARAÇÃO DA MATRIZ}POS:INTEIRO{CONTADOR DE POSICAO}PROCEDAPARA POS : = 1 INCREMENTO = 2ATE POS&nbsp; &gt; 10MOSTRE ( NUMEROS [ POS ] )FIM_PARAFIM    Exercício 25
Dado Um Vetor de 80 posições do tipo char, que deverá ser preenchido pelo usuário, faça um algoritmo que, a partir de uma letra digitada pelo usuário conte quantas vezes esta letra aparece dentro do vetor e informe o resultado da contagem ao final do processamento.
   Exercício 26
Dado o mesmo vetor preenchido no exercício anterior, faça um novo algoritmo capaz de identificar e contar, quantos pares de letras existem no vetor, ou seja quantas vezes aparecem duas letras repetidas uma após a outra.   Exercício 27
10) - Dado um vetor de 10 posições do tipo char faça uma algoritmo que permita que o usuário digite 10 letras, e que estas letras sejam colocadas nas respectivas posições dentro do vetor. O algoritmo no entanto não poderá permitir que seja digitada uma letra menor que a letra que foi digitadas anteriormente, ou seja a letra que será colocada na posição 2 deverá ser maior que a letra colocada na posição 1 , a letra colocada na posição três deverá ser maior que a letra digitada para a posição 2, e assim respectivamente até o final do vetor. A primeira letra poderá ser digitada livremente pelo usuário sendo que a regra acima somente se aplica as letras que forem colocadas da segunda posição em diante.   Exercício 28
Dado um vetor de 10 posições do tipo inteiro , que deverá ser preenchido pelo usuário, faça um algoritmo capaz de percorrer todo o vetor dobrando todos os numero que forem impares e dividindo pela metade todos os numero que forem pares colocando o resultado das operações nas mesmas posições dentro do vetor
   Exercício 29
Calculo do Digito verificador do CPF:
O CPF é formado por 9 digitos, mas 2 digitos verificadores que ficam no final.Estes dígitos verificadores são calculaods de acordo com os outros 9 digitos do CPF e servem para verificar a validade do CPF.Apresentamos aqui uma forma simplificada para o calculo destes dígitos:
Somar os produtos de cada um dos dígitos do CPF, pela sua respectiva posição, e pegar o resto da divisão inteira desta soma por 11. este resultado será o digito verificador 1Para calcular o digito verificador 2 , repetir o processo, somente alterando a multiplicação dos dígitos pela sua posição , de forma que as posições fiquem invertidas.
Faça um algoritmo capas de , uma vez informado os 9 digitos de um cpf qualquer, informar os 2 digitos verificadores deste cpf.
   Sub rotinas.
As subrotinas são divisões dos algoritmos, que são utilizadas para:
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Facilitar a manutenção dos algoritmos<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Dividir as tarefas.<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Dar maior organização aos algoritmos<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Para reaproveitar os Algoritmos.
Existem 2 tipos Basicos de Subrotinas:
Função:
È a subrotina que executa&nbsp; seus procedimentos, e ao final retorna um valor.
Procedimento:
È a subrotina que não faz retorno nenhum. Apenas executa os procedimentos a ela associados.
Para que possamos trabalhar com as subrotinas serão necessárias algumas alterações nos nossos algoritmos.
Argumentos
Um argumento é um tipo especial de variável utilizada em um algoritmo. Ele é especial porque dentro dele estará um valor&nbsp; predeterminado pelo usuário que esta utilizando o algoritmo.Isto quer dizer que o argumento é um valor que será colocado dentro de uma variável pelo usuário do algoritmo, que será utilizado pelo algoritmo como uma variável comum.Em tempo de processamento, isto quer dizer que os argumento serão passados como parâmetros na linha de comando da chamada do programa.A única diferença do argumento para uma variável comum é que ele já vem com um valor armazenado desde o inicio do algoritmo, enquanto que as outras variáveis necessitam ser inicializadas antes de serem usadas.No decorrer do algoritmo os argumentos poderão ser utilizados e alterados exatamente como as variáveis comuns, e inclusive deverão ser declarados.
Uma outra definição de Argumento seria que eles são variáveis destinadas a fazer a comunicação entre dois algoritmos.
Até agora temos trabalhamos com algoritmos isolados, mais na maioria das vezes teremos que trabalhas com vários algoritmos, cada um desempenhando uma função&nbsp; especifica dentro do que iremos chamar de sistema
Desta forma teremos algoritmos que irão se preocupar somente com a inclusão dos elementos em um vetor, enquanto que outro irá se preocupar apenas com a consulta dos valores já incluídos.
De alguma forma, estes algoritmos terão que trocar informações, e a melhor forma disto ser realizado é através de argumento.   
Comando Retorne
O comando RETORNE é&nbsp; responsável pelo retorno de informações de um algoritmo para outro.
Da mesma forma que um algoritmo poderá se comunicar com outro através de argumentos, um algoritmo responsável por exemplo por um calculo, poderá devolver uma resposta para outro algoritmo através do comando RETORNE.
Estes algoritmos são chamados Funções.
Muitas vezes necessitamos repetidamente de um cálculo, que iremos utilizar em vários algoritmos. Para evitar que tenhamos que repetir estes calculos em cada algoritmo em que ele é necessário, nós o transformamos em uma subrotina, e fazemos com que ele retorne a resposta ao nosso calculo de acordo com os ARGUMENTOS que passamos para ele.
No inicio desta apostila, vocês foram apresentado a uma serie de funções, que se destinam por exemplo, ao calculo da raiz quadrada, logaritmos, etc.
A chamada de uma função se faz da seguinte forma:
X : = SQR(4)
No exemplo acima a variável X depois de executada a função terá o valor 2, pois a função SQR calcula a raiz quadrada do argumento que for fornecido para ela. Neste caso o argumento é o 4.
Então, no exemplo acima, o quatro será o argumento que está sendo passado para a função, e o resultado do calculo da raiz quadrada será colocado em X devido ao uso do comando RETORNE.   
Listas:
É uma estrutura de dados linear que permite representar um conjunto de informações de forma a preservar uma relação de ordem entre eles. Esta estrutura deve também suportar os 4 tipos de atualizações :
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300;mso-bidi-font-weight:
bold'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span style='color:#993300;mso-bidi-font-weight:
bold'><![endif]--><!--[if supportFields]><span
style='color:#993300;mso-bidi-font-weight:bold'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Inclusão<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300;mso-bidi-font-weight:
bold'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span style='color:#993300;mso-bidi-font-weight:
bold'><![endif]--><!--[if supportFields]><span
style='color:#993300;mso-bidi-font-weight:bold'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Exclusão<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300;mso-bidi-font-weight:
bold'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span style='color:#993300;mso-bidi-font-weight:
bold'><![endif]--><!--[if supportFields]><span
style='color:#993300;mso-bidi-font-weight:bold'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Alteração<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Atravessamento.
Representação:
Exemplo
LISTA=(A,B,C,D,E)A=&gt;B=&gt;C=&gt;D=&gt;E
Para representar as lista dentro de nossos algoritmos nós vamos utilizar a estrutura do tipo matriz que foi vista anteriormente.
As listas podem ser alocadas segundo duas relações:
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300;mso-bidi-font-weight:
bold'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span style='color:#993300;mso-bidi-font-weight:
bold'><![endif]--><!--[if supportFields]><span
style='color:#993300;mso-bidi-font-weight:bold'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Relação de Contigüidade<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300;mso-bidi-font-weight:
bold'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span style='color:#993300;mso-bidi-font-weight:
bold'><![endif]--><!--[if supportFields]><span
style='color:#993300;mso-bidi-font-weight:bold'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Relação de Encadeamento.
Relação de Contigüidade:
É a forma mais simples de se relacionar os elementos de uma lista. Nela um elemento aponta sempre para o seu sucessor seqüencial.Desta forma a nossa lista estará sempre na sua ordem física, ou seja os elementos estarão dispostos fisicamente dentro da lista de maneira que a ordem entre os elementos seja mantida.
Dentro de uma lista nós devemos permitir 4 operações básicas:
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300;mso-bidi-font-weight:
bold'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span style='color:#993300;mso-bidi-font-weight:
bold'><![endif]--><!--[if supportFields]><span
style='color:#993300;mso-bidi-font-weight:bold'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Inclusão<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300;mso-bidi-font-weight:
bold'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span style='color:#993300;mso-bidi-font-weight:
bold'><![endif]--><!--[if supportFields]><span
style='color:#993300;mso-bidi-font-weight:bold'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Exclusão <!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300;mso-bidi-font-weight:
bold'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span style='color:#993300;mso-bidi-font-weight:
bold'><![endif]--><!--[if supportFields]><span
style='color:#993300;mso-bidi-font-weight:bold'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Alteração<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300;mso-bidi-font-weight:
bold'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='color:#993300;mso-bidi-font-weight:bold'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Atravessamento
   
Atravessamento
A operação de atravessamentos consiste em percorrer toda a lista, do seu começo até o seu final, visitando todos os seus elementos.O atravessamento começa pelo primeiro elemento da lista, mostra este elemento e vai sempre mostrado os próximos elementos até chegar no ultimo(N)
INICIOARGUMENTOSLISTA: MATRIZ[N] DE CHAR ; {DECLARAÇÃO DA LISTA}N:INTEIRO {NUMERO DE ELEMENTOS DE LISTA}VARIÁVEISCONT:INTEIRO;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {VARIAVEL DE CONTROLE DO LOOP}PROCEDA ATRAVESSAMENTO_CONTI.SE&nbsp; N &lt; 1 MOSTRE ('LISTA VAZIA!!!!')SENÃOCONT : = 0ENQUANTO CONT &lt; NCONT : = CONT + 1MOSTRE (LISTA [CONT])FIM_ENQUANTOFIM_SEFIM    
Inclusão em Listas Contíguas
A inclusão é a operação que visa a colocação de um novo elemento dentro da lista de maneira que a ordem entre os elementos seja mantida.Se&nbsp; a inclusão ocorre no final de lista , o seu procedimento é fácil. Porem se a inclusão acontecer no meio da lista, será necessário que todos os elementos após aquele que foi incluído sejam deslocados uma casa para baixo.
Note que para que possamos fazer uma inclusão nó devemos declarar a lista com 1 elemento a mais do que ele já possui, para reservar lugar para o novo elemento que será incluído.
Passo para Inclusão:
Criar      um espaço em branco&nbsp; no final da      lista
Aceitar      a letra que será incluída (ELEMENTO_NOVO)
Achar      a posição de inclusão da letra na lista (POS)
Fazer      uma critica para ver se a letra já não existe na lista
Remanejar      todos os elementos abaixo da posição de inclusão uma posição para baixo      començando de baixo para cima.
Incluir      o elemento na posição de inclusão.
N: =      N + 1

INICIO ARGUMENTOS:LISTA:MATRIZ [N+1] DE CHAR {A LISTA AONDE SERÁ FEITA A INCLUSÃO}N:INTEIRO{NUMERO DE ELEMENTOS DA LISTA}VARIAVEISPOS:INTEIRO {PARA ACHAR A POSIÇÃO DE INCLUSÃO}ELEMENTO_NOVO {O NOVO ELEMENTO A SER INCLUIDO}CONT :INTEIRO {VARIAVEL DE CONTROLE DO LOOP}PROCEDA INCLUSAO_CONTIMOSTRE(“DIGITE A LETRA PARA INCLUSÃO”)LEIA (ELEMENTO_NOVO)POS: = 1ENQUANTO POS &lt; = N E LISTA[POS]&lt; ELEMENTO_NOVOPOS: = POS+1FIM_ENQUANTOSE LISTA[POS] = ELEMENTO_NOVOMOSTRE (“LETRA JÁ EXISTE NA LISTA!!!!”)SENÃOCONT: = NENQUANTO CONT &gt; = POSLISTA [ CONT+1 ] : = LISTA [ CONT ]CONT : = CONT - 1FIM_ENQUANTOLISTA [ POS ] : = ELEMENTO_NOVON : = N + 1FIM-SEFIM.    
Alteração em Listas Contíguas
A alteração é o processo aonde se altera o conteúdo de um elemento que já exista na lista , para um novo valor especificado pelo usuário.
Passos par Alteração:
<!--[if !supportLists]-->1.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Aceitar a Letra que vai ser alterada (ELEMENTO)<!--[if !supportLists]-->2.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Aceitar a nova Letra (ELEMENTO_NOVO)<!--[if !supportLists]-->3.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Achar a posição de alteração(POS)<!--[if !supportLists]-->4.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Fazer uma critica para ver se a letra existe na lista<!--[if !supportLists]-->5.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Fazer uma critica para ver se a alteração não vai quebrar a ordem da lista<!--[if !supportLists]-->6.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Fazer a alteração.
Na hora de fazer uma alteração deve-se tomar cuidado para que o novo valor do elemento não altere a ordem da lista.Para&nbsp; se certificar que o novo valor do elemento da lista , esta compatível com a ordem da lista ,ou seja se a alteração deste valor não vai comprometer a ordem da lista devemos fazer alguns testes.
Para se fazer estes testes existem 4 situações:
     Situação 1
      
      1  
      1      NOVO  
   Situação 2
      
      1  
      1      NOVO  
      2      C  
      3      D  
   Situação 3
      
      1  
      1      A  
      2      B  
      3      NOVO  
   Situação 4
      
      1  
      1      A  
      2      NOVO  
      3      C  

     
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Na situação 1, o que nós temos é que a quantidade de elementos da lista é igual a 1 , neste caso qualquer valor será permitido para .<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Na situação 2 o elemento que desejamos alterar esta no começo da lista, e a lista tem mais de um elemento. Neste caso , o novo elemento deverá ser menor que o elemento na próxima posição da lista&nbsp; para que a alteração possa ser feita.<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Na situação 3 o elemento que se deseja alterar é o ultimo elemento da lista, e a lista tem mais de um elemento. Neste caso , o novo elemento deverá ser maior que o elemento que esta na posição anterior da lista.<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Na Situação 4 , que é o mais comum, o elemento que se deseja alterar está entre dois elementos de uma lista , e esta lista possui mais do que 2 elementos. Neste caso , o novo elemento deverá ser:<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300'><span
style='mso-element:field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='color:#993300'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Maior que o elemento na posição anterior da lista , e<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300'><span
style='mso-element:field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='color:#993300'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Menor que o elemento na posição posterior da lista.
   
INICIO ARGUMENTOSLISTA : MATRIZ [ N ] DE CHAR&nbsp;&nbsp; {LISTA PROPRIAMENTE DITA}N:INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{QUANTIDADE DE ELEMENTOS NA LISTA}VARIAVEISPOS:INTEIROELEMENTO:CHARNOVO_ELEMENTO:CHARALTERA:LOGICOPROCEDA ALTERACAO_CONTIMOSTRE (“DIGITE A LETRA PARA ALTERAÇÃO”)LEIA (ELEMENTO)MOSTRE (“DIGITE A NOVA LETRA”)LEIA (NOVO_ELEMENTO)POS: = 1ENQUANTO POS &lt; = N E LISTA [POS]&lt;&gt; ELEMENTOPOS: = POS+1FIM_ENQUANTOSE POS &gt; N MOSTRE (“ALTERAÇÃO INVALIDA”)SENÃO ALTERA: = FALSOCASON = 1&nbsp;&nbsp;&nbsp;&nbsp; {SITUAÇÃO 1}ALTERA: = VERDADEIROPOS = 1&nbsp; {SITUAÇÃO 2}SE NOVO_ELEMENTO &lt; LISTA[POS + 1]ALTERA: = VERDADEIROFIM_SEPOS = N&nbsp;&nbsp; {SITUAÇÃO 3}SE NOVO_ELEMENTO &gt; LISTA[POS – 1]ALTERA: = VERDADEIROFIM_SESENÃO&nbsp; {SITUAÇÃO 4}SE NOVO_ELEMENTO &gt; LISTA[POS –1] E &nbsp;&nbsp;&nbsp;&nbsp; NOVO_ELEMENTO &lt; LISTA[POS + 1ALTERA:=VERDADEIROFIM_SEFIM CASOSE ALTERA=VERDADEIROLISTA&nbsp; [POS] : = NOVO_ELEMENTOSENÃOMOSTRE (“ALTERAÇÃO INVALIDA”)FIM_SEFIM_SEFIM   
Exclusão em Listas Contíguas.
A exclusão é o processo de eliminação de um elemento já existente na lista. Para excluir um elemento em uma lista contígua deve-se antecipar todos os elementos abaixo do elemento&nbsp; a ser excluído em uma posição. Isto será feito por dois motivos, primeiro para excluir fisicamente o elemento da lista , e segundo para não deixar um espaço em branco na lista.
Passos para Exclusão
<!--[if !supportLists]-->1.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Aceitar a Letra que vai ser excluída (ELEMENTO)<!--[if !supportLists]-->2.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Achar a posição de exclusão(POS)<!--[if !supportLists]-->3.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Verificar se a letra esta na lista<!--[if !supportLists]-->4.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Remanejar todos os elementos abaixo da posição de exclusão (POS) uma posição para cima começando de cima para baixo.<!--[if !supportLists]-->5.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->N: = N – 1
INICIOARGUMENTOSLISTA : MATRIZ [ N ] DE CHAR {MATRIZ PARA ARMAZENAR A LISTA}N:INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {NUMERO DE ELEMENTOS NA LISTA}VARIAVEISPOS:INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {POSIÇÃO DO ELEMENTO A SER EXCLUIDO}CONT :INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {VARIAVEL DE CONTROLE DO LOOP}ELEMENTO:CHAR&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {LETRA QUE VAI SER EXCLUIDA}PROCEDA EXCLUSÃO_CONTIMOSTRE(“DIGITE A LETRA PARA EXCLUSÃO”)LEIA (ELEMENTO)POS: = 1ENQUANTO POS &lt; = N E LISTA [POS]&lt;&gt; ELEMENTOPOS: = POS+1FIM_ENQUANTOSE POS &gt; N MOSTRE (“EXCLUSÃO INVALIDA”)SENÃO CONT: = POSENQUANTO CONT &lt;&nbsp; N LISTA [CONT] : = LISTA [CONT+1]CONT : = CONT + 1FIM_ENQUANTOLISTA [N] : = NULON: = N - 1FIM_SEFIM.
   
Lista Encadeadas
Uma lista linear é dita encadeada quando um elemento aponta sempre para o próximo elemento, mesmo que eles não sejam contíguos. Ou seja , em cada elemento da lista nós teremos um ponteiro, que ira apontar para o próximo elemento da lista, mesmo que este elemento não seja o próximo fisicamente na lista .Para que possamos entender as listas encadeadas será preciso entender os conceitos de ordem física e ordem lógica de uma lista .
Ordem Física
É a ordem seqüencial na qual os elementos estão colocados dentro da lista. Ou seja é a ordem de inclusão dos elementos dentro da lista.
Ordem Lógica
É a ordem conseguida através dos ponteiros da lista. O ponteiro é um numero que esta em cada elemento da lista e que indica qual&nbsp; é a próxima posição física que deve ser visitada para que a ordem da lista possa ser mantida .
No caso das listas contíguas , o próximo elemento sempre era a próxima posição física da lista , mas no caso das listas encadeadas , isto não ocorre, porque o próximo elemento da lista será determinado por seu ponteiro, e não será necessariamente a próxima posição física da lista .
Como se pode perceber, no caso das lista contíguas, estudadas anteriormente, a ordem física da lista corresponde a ordem lógica, o que não acontece nas lista encadeadas.
Para que possamos trabalhar com lista encadeadas devemos ainda conhecer um outro conceito, o descritor.O descritor é um registro que contem informações sobre a lista. No nosso caso , o descritor terá uma única informação: a posição física do inicio da lista .O descritor será passado como argumento para todos os algoritmos de listas encadeadas.
Antes ainda de começarmos a desenvolver os algoritmos existe outro ponto a ser esclarecido:Com a criação de um ponteiro para cada elemento da lista, nós teremos que trabalhar com dois dados de tipo diferente em uma mesma estrutura. Já que o nosso elemento é do tipo CHAR , e o ponteiro é um numero INTEIRO. Para solucionar este problema , nós iremos lançar mão de um recurso estudado anteriormente, o REGISTRO.   O registro é a única estrutura de dados que nos permite trabalhar com diferentes tipos de dados dentro de uma mesma variavel. Como nós temos utilizado a matriz para representar as nossa listas, nada mais lógico que utilizarmos um matriz formada por registros para podermos representar uma lista encadeada.Uma matriz de registros é uma estrutura singular, aonde cada linha da minha matriz corresponde a um registro pré-definido que contem informações de tipos diferentes, permitindo desta forma, que se possa armazenar uma lista encadeada dentro da estrutura de matrizes 
Desta forma, para declarar uma lista encadeada vamos fazer da seguinte forma:
Primeiro criamos o Registro para armazenar os dados da lista:
REG_LISTA:REGISTROLETRA:CHARPROXIMO:INTEIROFIM_REGISTRO
Depois declaramos a lista pripriamento dita:
LISTA:MATRIZ [ N ] DE REG_LISTA
Além de tudo isto , ainda existe um outro conceito a ser discutido, o valor NULO.O NULO&nbsp; é um valor&nbsp; especial que irá retornar todas as vezes que algum algoritmo tentar acessar um elemento além do final da lista. O nulo é um valor que indica que não existem mais posições a serem pesquisadas na lista .   
Atravessamento
Atravessar uma lista significa percorre-la , em ordem, de forma que cada um de seus elementos seja visitado uma única vez.Como foi feito na Lista contígua, o atravessamento começa pelo incio da lista e vai mostrando todos os seus elementos até o final. A diferença aqui , é que o atravessamento não é feito pela ordem física , mas sim pela ordem lógica.O atravessamento deve começar pelo Descritor, e ir mostrado os elementos um por um , sempre indo para o proximo, até que o proximo seja nulo.
INICIOARGUMENTOSLISTA : MATRIZ [ N ]&nbsp; DE REG_LISTA&nbsp; {DECLARAÇÃO DA LISTA }N :INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {NUMERO DE ELEMENTOS DA LISTA}DESCRITOR: INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {POSIÇÃO FISICA DO INICIO DA LISTA}VARIAVEISREG_LISTA : REGISTROLETRA:CHAR&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {DECLARAÇÃO DO REGISTRO DA LISTA}PROXIMO : INTEIROFIM_REGISTRO CONT:INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{VARIAVEL DE CONTROLE DO LOOP}PROCEDA ATRAVESSAMENTO_ENCASE DESCRITOR = NULOMOSTRE (“LISTA VAZIA!!!!!”)SENÃOCONT: = DESCRITOR&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {INICIO DA LISTA}ENQUANTO&nbsp;&nbsp; CONT &lt;&gt; NULOMOSTRE (LISTA [CONT].LETRA) CONT : =&nbsp; LISTA [CONT].PROXIMOFIM_ENQUANTOFIM-SEFIM.
   
Busca do Espaço Vazio.
Nas listas encadeadas poderá ocorrer uma situação que não era possível nas lista contíguas:Na lista encadeada o algoritmo de exclusão poderá deixar um elemento vazio no meio da lista, e neste caso , nós poderíamos aproveitar este espaço para fazer novas inclusões na lista , evitando assim que a lista fique cheia de espaços em branco no transcorrer de diversas atualizações.Para tanto, será necessário a criaão de um algoritmo capaz de identificar e reutilizar estes espaços em branco. Nós vamos chama-lo de ELEMENTO_VAZIO.Este algoritmo deverá percorrer a lista pela ordem física, e procurar pelo primeiro espaço vazio que encontrar. Caso o algoritmo não localize nenhum espaço vazio, ele deverá "CRIAR" este espaço, simplesmente aumentando o numero de elementos da lista(N).
INICIOARGUMENTOSLISTA : MATRIZ [N]&nbsp; DE REG_LISTA&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {DECLARAÇÃO DA LISTA}N:INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {NUMERO DE ELEMENTOS DA LISTA}VARIAVEISREG_LISTA : REGISTROLETRA: CHAR&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {DECLARAÇÃO DO REGISTRO DA LISTA}PROXIMO : INTEIROFIM_REGISTROCONT:INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {VARIAVEL DE CONTROLE DO LOOP}PROCEDA ELEMENTO_VAZIOCONT: = 1 ENQUANTO CONT &lt; = N&nbsp; E&nbsp; LISTA [CONT].LETRA &lt; &gt; NULO&nbsp; CONT: = CONT + 1&nbsp;&nbsp; {ATE ACABAR A LISTA OU ACHAR UM NOME NULO}FIM_ENQUANTOSE CONT &gt; N N : = N + 1RETORNE (N)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {NÃO ACHOU ESPAÇO VAZIO E AUMENTOU A LISTA}SENÃORETORNE (CONT)&nbsp;&nbsp;&nbsp; {ACHOU ESPAÇO VAZIO}FIM_SEFIM.
   
Inclusão em Listas Encadeadas.
O processo de inclusão de um elemento B , após um elemento A , dentro de uma lista encadeada é feito da seguinte forma :<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300'><span
style='mso-element:field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='color:#993300'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Procura-se um elemento vazio<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300'><span
style='mso-element:field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='color:#993300'><![endif]--><!--[if supportFields]><span
style='color:#993300'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Coloca-se ali a informação do elemento&nbsp; B<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300'><span
style='mso-element:field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='color:#993300'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O próximo de B passa a ser o próximo de A <!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300'><span
style='mso-element:field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='color:#993300'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O próximo de A passa a ser a posição física de BNote que no caso da lista estiver vazia (DESCRITOR = NULO), ou se o elemento for incluído no inicio da lista ( A = NULO) , então o descritor deverá ser ajustado para o valor de B , que passará a ser o inicio da lista, o e próximo de B passará a ser o descritor.Exemplo:No exemplo abaixo , o descritor aponta para o elemento numero 4, logo o inicio da lista é no numero 4.O algoritmo do elemento vazio localizou um espaço vazio na posição 2, Portanto POS = 2.Atualmente a lista tem somente dois elementos: <!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300'><span
style='mso-element:field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='color:#993300'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; A na posição 4 e ,<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300'><span
style='mso-element:field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='color:#993300'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; C na posição 7.Como o elemento a ser inclido é o B então ANT = 4Para incluir o B no espaço vazio 2(POS), devemos :<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300'><span
style='mso-element:field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='color:#993300'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Colocar o C no espaço vazio 2(POS)<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300'><span
style='mso-element:field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='color:#993300'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Alterar o próximo de 2(POS) para 7(O próximo de ANT)<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300'><span
style='mso-element:field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='color:#993300'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Alterar o próximo de 4(ANT) para 2(POS)<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt;color:#993300'><span
style='mso-element:field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='color:#993300'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O registro 7 se mantém inalterado.
<!--[if gte vml 1]><v:shape id="_x0000_i1032" type="#_x0000_t75"
 style='width:236.25pt;height:312pt' o:ole="">  <v:imagedata src="file:///C:\Users\ITALO-~1\AppData\Local\Temp\msohtmlclip1\01\clip_image015.wmz"
  o:title=""/> <![endif]--><!--[if !vml]--><!--[endif]--><!--[if gte mso 9]>  <o:OLEObject Type="Embed" ProgID="MSDraw" ShapeID="_x0000_i1032"
  DrawAspect="Content" ObjectID="_1376409088">   <![endif]-->

   
Passos para inclusão:
1. Aceitar a letra que vai ser incluida2. Achar a posição de inclusão(POS)3. Achar a posição anterior a posição de inclusão(ANT)4. Verificar se a letra já não existe na lista5. Colocar a letra na posição de inclusão(POS)6. O proxino de POS passa a ser o próximo de ANT7. O proxino de ANT para a se POS
  IMPORTANTE:O PRÓXIMO DE POS PASSA A SER O PRÓXIMO DE ANT O PRÓXIMO DE ANT PASSA A SER A POS

Casos Especiais:
Como foi falado anteriormente existem casos especiais. Estes casos especiais acontencem quando a operação de inclusão envolve o Descritor. Isto acontece quando vamos incluir o elmento que vai ser o primeiro elemento da lista.Neste caso então , não será possível emcontrar o elemento anterior, como esta previsto no passo 3 para insclusão(ANT = NULO) neste caso então devemos aplicar os seguintes passos especiais:
6.&nbsp; O próximo de POS passa ser o DESCRITOR7.&nbsp; O DESCRITOR passa a ser POS
Note que nos casos especiais, como o valor de ANT não pode ser encontrado então nós substituimos ANT por DESCRITOR, que na pratia seria o ANT do primeiro elemento da lista.

   
INICIOARGUMENTOSLISTA : MATRIZ [ N ]&nbsp; DE REG_LISTA&nbsp;&nbsp;&nbsp;&nbsp; {DECLARAÇÃO DA LISTA }N:INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; { O NUMERO DE ELEMENTOS DA LISTA}DESCRITOR: INTEIRO &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{ O INICIO DA LISTA}VARIAVEISREG_LISTA : REGISTROLETRA:CHAR&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {DECLARAÇÃO DO REGISTRO DA LISTA }PRÓXIMO : INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; FIM_REGISTROPOS:INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {POSIÇÃO DE INCLUSÃO DO NOVO ELEMENTO }ANT:INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {POSIÇÃO ANTERIOR DO NOVO ELEMENTO }ELEMENTO_NOVO: CHAR&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {A NOVA LETRA QUE VAI SER INCLUIDA}CONT: INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {VARIAVEL DE CONTROLE DE LOOP}PROCEDA INCLUSAO_ENCAMOSTRE (“DIGITE A LETRA PARA INCLUSÃO”)LEIA (NOVO_ELEMENTO)POS: = ELEMENTO_VAZIO (LISTA , N)ANT: = NULOCONT: = DESCRITORENQUANTO CONT &lt; &gt; NULO E LISTA [CONT]. LETRA &lt; ELEMENTO_NOVOANT : = CONTCONT: = LISTA [CONT].PROXIMOFIM_ENQUANTOSE LISTA[CONT]. LETRA = NOVO_ELEMENTOMOSTRE (“INCLUSÃO INVALIDA!!!!”)SENÃO LISTA [POS] . LETRA : = ELEMENTO_NOVOSE ANT = NULO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {CASO ESPECIAL}LISTA [POS] . PROXIMO : = DESCRITOR DESCRITOR : = POSSENAO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;{CASO NORMAL}LISTA [POS]. PROXIMO : = LISTA [ANT]. PROXIMOLISTA [ANT]. PROXIMO : =&nbsp; POSFIM-SEFIM_SEFIM    
Alteração em Lista Encadeadas.
A alteração em listas encadeadas é muito parecida com a alteração em listas contíguas. Da mesma forma que na lista contígua será necessário tomar o cuidado para que o novo valor não altere a ordem da lista .Em essência, o algoritmo será o mesmo, apenas com algumas diferenças.A primeiro é que na hora de se fazer as criticas, o proximo elemento deverá ser obtido com a utilização dos ponteiros. A segnda é que&nbsp; o elemento anterior, deverá ser conseguindo atravez de uma pesquisa sequancial pela lista, uma vez que não há outra forma de conseguinr esta informação.
Passos para alteração:
Aceitar      a letra que vai ser alterada(ELEMENTO)
Aceitar      a nova letra (NOVO_ELEMENTO)
Achar      a posição de alteração(POS)
Achar      a posição anterior do elemento que vai ser alterado(ANT)
Verificar      se a letra a ser alterada existe na lista
Fazer      a critica para ver se a alteração não vai quebrar a ordem da lista
Alterar      o elemento.

Vale lembrar que no passo 6 a critica deverá ser feita de acordo com as situações vistas no algoritno de alteração em listas contíguas.   INICIOARGUMENTOSLISTA : MATRIZ [ N ]&nbsp; DE REG_LISTA&nbsp;&nbsp;&nbsp;&nbsp; {DECLARAÇÃO DA LISTA }N:INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; { O NUMERO DE ELEMENTOS DA LISTA}DESCRITOR: INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; { O INICIO DA LISTA}VARIAVEISREG_LISTA : REGISTROLETRA:CHAR&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {DECLARAÇÃO DO REGISTRO DA LISTA }PRÓXIMO : INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; FIM_REGISTROPOS,ANT,CONT:INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ELEMENTO, ELEMENTO_NOVO:CHAR&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ALTERA:LOGICO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {FLAG DE ALTERAÇÃO}PROCEDA ALTERACAO_ENCAMOSTRE (“DIGITE A LETRA PARA ALTERAÇÃO”)LEIA (ELEMENTO)MOSTRE (“DIGITE A NOVA LETRA”)LEIA (NOVO_ELEMENTO)ANT: = NULOPOS: = DESCRITORENQUANTO POS &lt;&gt; NULO E LISTA [POS].LETRA&lt;&gt; ELEMENTOANT: =&nbsp; POSPOS: = LISTA[POS] . PROXIMOFIM_ENQUANTOSE POS = NULO MOSTRE (“ALTERAÇÃO INVALIDA”)SENÃO ALTERA: = FALSOCASOANT = NULO E LISTA[POS]. PROXIMO = NULO&nbsp;&nbsp;&nbsp;&nbsp; {SITUAÇÃO 1}ALTERA: = VERDADEIROANT = NULO&nbsp; {SITUAÇÃO 2}SE NOVO_ELEMENTO &lt; LISTA[LISTA[POS].PROXIMO].LETRAALTERA: = VERDADEIROFIM_SELISTA[POS].PROXIMO = NULO&nbsp;&nbsp; {SITUAÇÃO 3}SE NOVO_ELEMENTO &gt; LISTA[ANT].LETRAALTERA: = VERDADEIROFIM_SESENÃO&nbsp; {SITUAÇÃO 4}SE NOVO_ELEMENTO &gt; LISTA[ANT].LETRA E &nbsp;&nbsp;&nbsp;&nbsp; NOVO_ELEMENTO &lt; LISTA[LISTA[POS].PROXIMO].LETRAALTERA:=VERDADEIROFIM_SEFIM CASOSE ALTERA=VERDADEIROLISTA&nbsp; [POS].LETRA : = NOVO_ELEMENTOSENÃOMOSTRE (“ALTERAÇÃO INVALIDA”)FIM_SEFIM_SEFIM.
   
Exclusão em Listas Encadeadas.
Neste caso , a maior dificuldade reside em determinar qual o elemento que tem como próximo , o elemento que será excluído.Essa busca tem que ser feita por varredura seqüencial , e uma vez encontrado o elemento, a exclusão é feita da seguinte forma:O próximo do elemento anterior ao que será excluído , passa a ser o próximo do elemento que será excluído.Depois de ajustar os ponteiros devemos mover o valor nulo para o ponteiro e para o elemento na posição em que ocorreu a exclusão.Novamente aqui&nbsp; podem aparece os casos especias, que acontecem quando for solicitada a exclusão do primeiro elemento da lista(DESCRITOR), neste caso, o priximo do elemento excluído passa a ser o novo descritor.
Passos para Exclusão:
Aceitar      a letra que vai ser excluída
Achar      a posição de Exclusão(POS)
Achar      a posição alteriror da letra que vai ser excluída(ANT)
Verificar      se a letra&nbsp; a ser excluída existe na      lista
O      próximo de ANT passar a ser o Proxino de POS
Colocar      NULO na posição que foi excluída.

  IMPORTANTE :O PRÓXIMO DE ANT PASSA A SER O PRÓXIMO DE POS.
Casos Especiais:
Caso não se possa localizar a letra anterior (ANT=NULO) isto quer dizer que o elemento que esta sendo excluído é o descritor da lista, neste caso não poderemos aplicar o passo 5 uma vez que o&nbsp; valor de ANT não existe. Neste caso devemos aplicar um passo 5 especial:
5. O DESCRITOR passa a ser o próximo de POS.
Note que este passo especial funcionar até mesmo se o elemento for o único da lista, pois neste caso o próximo é igual a NULO , e com a exclusão deste elemento o descritor passa ser ser NULO, o que indica uma lista vazia.   
INICIOARGUMENTOSLISTA : MATRIZ [ N ]&nbsp; DE REG_LISTA {DECLARAÇÃO DA LISTA }N : INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {QUANTIDADE DE ELEMENTOS DA LISTA}DESCRITOR: INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; { POSIÇÃO DE INICIO DA LISTA}VARIAVEISREG_LISTA : REGISTROLETRA:CHAR&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {DECLARAÇÃO DO REGISTRO DA LISTA }PRÓXIMO : INTEIROFIM_REGISTROPOS:INTEIROANT:INTEIROELEMENTO: CHARPROCEDA EXCLUSÃO_ENCAMOSTRE ( “ DIGITE A LETRA PARA EXCLUSÃO”)LEIA ( ELEMENTO)ANT: =NULOPOS: =DESCRITORENQUANTO POS &lt; &gt;&nbsp; NULO E LISTA[POS].LETRA &lt; &gt; ELEMENTO ANT: = POSPOS : = LISTA[ POS ]. PROXIMOFIM_ENQUANTOSE POS = NULO MOSTRE ( “ EXCLUSÃO INVALIDA”)SENÃOSE ANT = NULODESCRITOR : = LISTA [POS] . PROXIMOSENAOLISTA[ ANT ].PROXIMO : = LISTA[ POS ].PROXIMOFIM_SELISTA[ POS ].LETRA : = NULOLISTA[ POS ].PROXIMO : = NULO FIM_SEFIM.   
Lista Duplamente Encadeadas.
A lista duplamente encadeada tem como característica o fato de que cada elemento possui dois ponteiros. O primeiro indica o sucessor do elemento , e o segundo o seu antecessor.
No caso das listas duplamente encadeadas, o descritor terá duas informações:
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O primeiro elemento da lista<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O ultimo elemento da lista.
Para que possamos representar ambas esta informções o registro passara a se declado como um registro, da seguinte forma:
DESCRITOR : REGISTROINICIO : INTEIROFINAL : INTEIROFIM_REGISTRO
Para que possamos trabalhar com lista duplamente encadeadas, nos deveremos incluir um novo campo no registro usado para montar a matriz que servirá para armazenar a lista. Este novo campo vai conter o endereço físico do elemento anterior ao elemento atual. Da mesma forma , na lista duplamente encadeada ainda vai existir o ponteiro que indica qual é a próxima posição do elemento atual. 
REG_LISTA:REGISTROANTERIOR:INTEIROLETRA:CHARPROXIMO:INTEIROFIM_REGISTRO

Note que com estas informações você poderá escolher em que ordem você deseja trabalhar com a lista, ela pode ser crescente ou decrescente.
   
Atravessamento em Lista Duplamente  Encadeadas.
O atravessamento em listas duplamente encadeadas é muito parecido com o atravessamento em lista encadeadas, com a diferença que você poderá escolher a ordem em qual a lista será atravessada.Para este fim será incluído um novo argumento chamado ORDEM, que deverá indicar a ordem do atravessamento.O atravessamento em ordem crescente começa pelo DESCRITOR.INICIO, e vai sempre pelo PROX até chegar ao final da lista. Já o atravessamento em ordem descrescente começa pelo DESCRITOR.FINAL e vai sempre pelo ANT até chegar ao inicio da Lista.Note que de qualquer forma o final ou o inicio da lista vai ser identificado por um valor NULO nos ponteiros, pois o PROX da ultima LETRA da lista será NULO da mesma forma que o ANT da primeira letra.
INICIOARGUMENTOLISTA : MATRIZ [ N ]&nbsp; DE REG_LISTA&nbsp;&nbsp;&nbsp; {DECLARAÇÃO DA LISTA }DESCRITOR : REGISTRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {DECLARAÇÃO DO DESCRITOR}INICIO: INTEIROFINAL : INTEIROFIM_REGISTRON : INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {NUMERO DE ELEMENTOS DA LISTA}ORDEM&nbsp; : CHAR&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {INDICA A ORDEM DE ATRAVESSAMENTO}&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {"C"=&gt;ORDEM CRESCENTE}&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {"D"=&gt;ORDEM DECRESCENTE}VARIAVEISREG_LISTA : REGISTROANTERIOR: INTEIROLETRA:CHAR&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {DECLARAÇÃO DO REGISTRO DA LISTA }PRÓXIMO : INTEIROFIM_REGISTROCONT: INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {VARIAVEL DE CONTROLE DO LOOP}PROCEDA ATRAVESSAMENTO_DUPLA_ENCASE ORDEM = "C"CONT: = DESCRITOR . INICIOSENÃOCONT : = DESCRITOR . FINALFIM_SEENQUANTO CONT &lt; &gt; NULOMOSTRE LISTA [ CONT ].LETRASE ORDEM = "C "CONT :&nbsp; = LISTA[ CONT ].PROXIMOSENAOCONT : = LISTA[ CONT ].ANTERIORFIM_SEFIM_ENQUANTOFIM.   Inclusão em Listas Duplamente  Encadeadas.
Para a inclusão em listas duplamente encadeadas nós vamos continuar&nbsp; precisando do algoritmo da busca do elemento vazio, mas não será necessário faze-lo novamente, pois poderemos usar o feito para lista encadeadas alterando apenas o registro usado para declarar a matriz.o processo de inclusão de um elemento A após um elemento B em uma lista duplamente encadeada é feito a seguinte forma:
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Procura-se um elemento vazio(POS)<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Coloca-se ali a informação do elemento B<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O próximo de A passar a ser a posição física de B<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O próximo de B passa a ser o próximo de A<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O anterior do próximo de A passa a ser a posição física de B<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O anterior de B passa a ser a posição física de A.
Note que devemos prestar a atenção para o caso de não existir um elemento anterior ao incluído(A), ou para o caso do elemento incluído ser o primeiro da lista , ou o ultimo da lista , neste caso devemos fazer as alterações necessárias no descritor.<!--[if gte vml 1]><v:shape
 id="_x0000_i1033" type="#_x0000_t75" style='width:236.25pt;height:312pt'
 o:ole="">  <v:imagedata src="file:///C:\Users\ITALO-~1\AppData\Local\Temp\msohtmlclip1\01\clip_image017.wmz"
  o:title=""/> <![endif]--><!--[if !vml]--><!--[endif]--><!--[if gte mso 9]>  <o:OLEObject Type="Embed" ProgID="MSDraw" ShapeID="_x0000_i1033"
  DrawAspect="Content" ObjectID="_1376409089">   <![endif]-->


   Passos para inclusão:
1. Aceita a letra que vai ser incluida2. Achar a posição de inclusão(POS)3. Achar a posição anterior a posição de inclusão(ANT)4. Verificar se a letra já não existe na lista5. Colocar a letra na posição de inclusão(POS)6. O proxino de POS passa a ser o próximo de ANT7. O anterior de POS passa a ser ANT8. O próximo de ANT passa a ser POS9. O anterior do próximo de POS passa a ser POS
  IMPORTANTE: O proxino de POS passa a ser o próximo de ANTO anterior de POS passa a ser ANTO próximo de ANT passa a ser POSO anterior do próximo de POS passa a ser POS
Casos Especiais:

Da mesma forma que nas listas encadeadas nós teremos os casos especiais , só que nas listas duplamente encadeadas, nos teremos 2 casos especiais. O primeiro acontece quando vamos incluir um elemento que por ser o menor da lista , vai passar a ser o novo DESCRITOR.INICIO da lista. Neste caso o valor de ANT será igual a NULO, pois não será possível achar um elemento menor que ele na lista, e deveremos ajustar as regras para alterar o valor do DESCRITOR.INICIO.Neste primeiro caso especial será necessário substituir o passo 6 e o passo 8 pelos seguintes passo especiais:
6. O próximo de POS recebe DESCRITOR.INICIO8. DESCRITOR.INICIO recebe POS
O segundo caso acontece quando o elemento que vamos incluir é o maior elemento da lista, e neste caso passará a ser o DESCRITOR.FINAL da lista.Podemos identificar este caso especia quando o valor de Ant é igual ao valor deo DESCRITOR.FINAL, e neste caso devemos substituir o passo 9, e aplicar o seguinte passo especial:
9.&nbsp; DESCRITOR.FINAL recebe POS
   INICIOARGUMENTOSLISTA : MATRIZ [ N ]&nbsp; DE REG_LISTA&nbsp;&nbsp;&nbsp; {DECLARAÇÃO DA LISTA }N:INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {NUMERO DE ELEMENTOS DA LISTA}DESCRITOR :&nbsp; REGISTROINICIO:INTEIROFINAL:INTEIROFIM_REGISTROVARIAVEISREG_LISTA : REGISTROANTERIOR: INTEIROLETRA: CHAR&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {DECLARAÇÃO DO REGISTRO DA LISTA }PRÓXIMO : INTEIROFIM_REGISTROELEMENTO_NOVO:CHARPOS, ANT,CONT: INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; PROCEDA INCLUSÃO_DUPLA_ENCAMOSTRE (“ DIGITE A LETRA PARA INCLUSÃO”)LEIA (ELEMENTO_NOVO)POS: = ELEMENTO_VAZIO (LISTA , N)ANT: = NULOCONT: = DESCRITOR.INICIOENQUANTO CONT &lt; &gt; NULO E LISTA [CONT]. LETRA &lt; ELEMENTO_NOVOANT : = CONTCONT: = LISTA [CONT].PROXIMOFIM_ENQUANTOSE LISTA [CONT]. LETRA = NOVO_ELEMENTOMOSTRE (“INCLUSÃO INVALIDA!!!!”)SENÃO LISTA [POS] . LETRA : = ELEMENTO_NOVOSE ANT = NULO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {PRIMEIRO CASO ESPECIAL}LISTA [POS] . PROXIMO : = DESCRITOR .INICIOLISTA [POS] . ANTERIOR : = ANTDESCRITOR : = POSLISTA [ LISTA [POS] . PROXIMO ].ANTERIOR : = POSSENAO&nbsp;&nbsp;&nbsp; SE ANT = DESCRITOR . FINAL {SEGUNDO CASO ESPECIAL}LISTA [ POS ] . PROXIMO : = LISTA [ ANT ] . PROXLISTA [ POS ] . ANTERIOR : = ANTLISTA [ ANT ] . PROXIMO : =&nbsp; POSDESCRITOR.FINAL : =&nbsp; POSSENÃO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;{CASO NORMAL}LISTA [ POS ] . PROXIMO : = LISTA [ ANT ] . PROXLISTA [ POS ] . ANTERIOR : = ANTLISTA [ ANT ] . PROXIMO : =&nbsp; POSLISTA[LISTA [ POS ] .PROXIMO]. ANTERIOR : =&nbsp; POSFIM_SEFIM-SEFIM_SEFIM 
   
Exclusão em Listas Duplamente  Encadeadas.
No caso da exclusão em listas duplamente encadeadas, não será necessário localizar o elemento anterior ao elemento que será excluído , como foi feito com as lista encadeadas. Esta informação estará disponível nos ponteiros do elemento que será excluído.Uma vez conhecida a posição física do elemento que será excluído a exclusão em lista duplamente encadeadas funciona da seguinte forma:
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O próximo&nbsp; do anterior de B passa a ser o próximo de B<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O anterior do próximo de B passa a ser o anterior de B<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Move nulo para os valores de B.

Note que devemos levar em consideração novamente o caso do item excluído ser o ultimo ou o primeiro elemento da lista , neste caso devemos proceder as alterações necessárias no descritor da lista, que serão vistas nos casos especiais:
Passos para inclusão:
1. Aceita a letra que vai ser excluida2. Achar a posição de Exclusão (POS)3. Achar a posição anterior a posição de Exclusão (ANT)4. Verificar se a letra existe na lista5. O proxino de ANT recebe o próximo de POS6. O anterior do próximo de POS recebe ANT7. Colocar NULO na letra Anterior e Proximo
  IMPORTANTE: O proxino de ANT recebe o próximo de POSO anterior do próximo de POS&nbsp; recebe ANT
Casos Especiais:
Novamente , caso a exclusão seja do primeiro ou do ultimo elemento da lista teremos os casos especiais.Se o valor de ANT for igual a nulo então o elemento que esta sendo excluído é o primeiro , e deveremos utilizar o seguinte passo especial:
5. DESCRITOR.INICIO recebe o proximo de POS
Caso o valor de POS seja igual ao valor de DESCRITOR.FINAL, então o elemento que estamos exclindo é o ultimo da lista e neste caso deveremos aplicar o seguinte passo especial:
6 . O DESCRITOR.FINAL recebe ANT
   INICIOARGUMENTOSLISTA : MATRIZ [ N ]&nbsp; DE REG_LISTA&nbsp;&nbsp;&nbsp; {DECLARAÇÃO DA LISTA }N: INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; { A QUANTIDADE DE ELEMENTOS DA LISTA}DESCRITOR :&nbsp; REGISTROINICIO :&nbsp; INTEIROFINAL : INTEIROFIM_REGISTROVARIAVEISREG_LISTA : REGISTROANTERIOR: INTEIROELEMENTO : CHAR&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {DECLARAÇÃO DO REGISTRO DA LISTA }PRÓXIMO : INTEIROFIM_REGISTROANT:INTEIROPOS:INTEIROELEMENTO: CHARPROCEDA EXCLUSÃO_DUPLA_ENCAMOSTRE ( “ DIGITE A LETRA PARA EXCLUSÃO”)LEIA ( ELEMENTO)ANT: =NULOPOS: =DESCRITOR.INICIOENQUANTO POS &lt; &gt;&nbsp; NULO E LISTA[POS].LETRA &lt; &gt; ELEMENTO ANT: = POSPOS : = LISTA[ POS ]. PROXIMOFIM_ENQUANTOSE POS = NULO MOSTRE ( “ EXCLUSÃO INVALIDA”)SENÃOSE ANT = NULO {PRIMEIRO CSO ESPECIAL }DESCRITOR : = LISTA [POS] . PROXIMOLISTA [ LISTA [ POS ] .PROXIMO ] . ANTERIOR : = ANTSENAOSE POS = DESCRITOR.FINAL {SEGUNDO CASO ESPECIAL}LISTA&nbsp; [ ANT ] . PROXIMO : = LISTA [ POS ] . PROXIMODESCRITOR . FINAL : = ANTSENÃO {CASO NORMAL}LISTA&nbsp; [ ANT ] . PROXIMO : = LISTA [ POS ] . PROXIMOLISTA [ LISTA [ POS ] .PROXIMO ] . ANTERIOR : = ANTFIM_SEFIM_SELISTA[ POS ]. ANTERIOR : = NULOLISTA[ POS ].LETRA : = NULOLISTA[ POS ].PROXIMO : = NULO FIM_SE
FIM.   
Alteração em Listas Duplamente  Encadeadas
O algoritmo de alteração em listas duplamente encadeadas, é praticamente idêntico ao algoritmo de alteração em listas encadeadas, sendo necessário apenas mudar a declaração dos registros para podermos armazenar o novo ponteiro e o novo valor do descritor. Tambem não será mais necessário o processo de achar o elemento anterior ao elemento que esta sendo alterado, pois esta informação já esta armazenada nos ponteiros da lista.
Por ser um algoritmo praticamente idêntico al de listas encadeadas, não será necessário repeti-lo aqui.   
Filas (Queue)
Filas são listas com acesso disciplinados do tipo FIFO (FIRST IN FIRST OUT), ou seja , o primeiro a entrar na fila será o primeiro a sair.As filas são comumente utilizadas para controle acesso a dispositivos. Normalemtne quando temos um ou poucos objetos que são necessários a vários outros objetos , teremos uma fila para controlar o acesso a este objeto. Um bom exemplo disso são as filas de impressão, para acesso a um HD, etc.Filas são estruturas facilmente encontradas em algoritmos , e o seu processo de atualização se divide em duas partes:
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; INSERÇÃO =&gt; Que sempre acontece no final da fila<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; REMOÇÃO =&gt; Que sempre acontece no topo da fila.
Como a quantidade de elementos em uma fila quase sempre é pequeno (&lt; 100) , normalmente elas são representadas através de listas, alocadas de acordo com uma relação de contigüidade.
Exemplo:     
A lista representada abaixo é composta por 4 elementos, sendo que o inicio está na posição 1 e o fim na posição 4.A fila está alocada em uma lista contígua de 5 elementos.   
  
      1      JOÃO      INICIO  
      2      MARIA      
  
      3      MARCIA      
  
      4      JOSE      FINAL  
      5      
      
  


     
   
Inserção em Filas
O processo de inclusão se dá sempre no elemento seguinte ao ultimo elemento da fila, desde que ele não ultrapasse a dimensão máxima da fila.

Note que para as filas, a quantidade de elementos da lista se refere a quantidade máxima de elementos que poderão ser colocados na fila, ou seja , é a dimensão máxima da fila. A dimensão da fila não pode ser aumentada dimamicamente.
INICIOARGUMENTOSFILA : MATRIZ [ N ] DE STRING[40]&nbsp;&nbsp; { A FILA}N:INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {NUMERO DE POSIÇÕES DA FILA}FINAL&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {POSIÇÃO OCUPADA PELO ULTIMO ELEMENTO DA FILA}NOME_NOVO:STRING [40] {NOME A SER INCLUIDO}PROCEDA INSERSÃO_FILASE&nbsp; FINAL &gt; = NMOSTRE ( " A FILA ESTA CHEIA ")SENÃOFILA [ FINAL + 1 ] : = NOME_NOVOFINAL : = FINAL + 1FIM_SEFIM.   
Remoção em Filas
O processo de remoção de um elemento em uma fila sempre se dá no inicio da lista, e conseqüentemente , todos os demais elementos de fila deverão ser remanejados uma posição para cima.
INICIOARGUMENTOSFILA : MATRIZ [ N ] DE STRING[40] {A FILA}N:INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {NUMERO DE POSIÇÕES DA FILA}FINAL:INTEIROVARIAVEISCONT : INTEIRO PRIMEIRO: STRING[40]PROCEDA REMOÇÃO_FILASE FINAL = 0MOSTRE ( " LISTA VAZIA ")SENÃOPRIMEIRO : = FILA [ 1 ] CONT: = 1ENQUANTO CONT &lt; = FINALFILA [ CONT ] : = FILA [ CONT + 1 ]CONT : = CONT + 1FIM_ENQUANTOFILA [ FINAL ] : = NULOFINAL : = FINAL - 1RETORNE (PRIMEIRO)FIM_SEFIM   
Pilhas (Stack)
São listas com acesso disciplinado do tipo LIFO (LAST IN FIRST OUT), ou seja o ultimo a entrar será o primeiro a sair.As pilhas normalmente são utilizadas para controlar a execusão de tarefas interdependentes, ou seja , tarefas que para serem finalizadas dependes da finalização de outras tarefas. Na informática um exemplo de utilização de pilhas é no controle de chamadas de sub rotinas.São estruturas muito comuns em algoritmos e o seu processo de atualização se divide em duas partes:
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; INSERÇÃO =&gt; É a colocação de um novo elemento na pilha<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; REMOÇÃO&gt; É a remoção de um elemento da pilha.
Tanto a inserção como a remoção são realizados no topo da pilha.
Exemplo.     
A lista ao lado representada é composta por 4 elementos, estando inserida em uma lista com&nbsp; 6 elementos. O topo desta lista está na posição 4.   
  
      6      
  
      5      
  
      4      BRANCO  
      3      AZUL  
      2      AMARELO  
      1      VERDE  
     
Como a quantidade de elementos em uma fila quase sempre é pequeno ( &lt; 100 ) , normalmente são representadas através de listas alocadas de acordo com uma relação&nbsp; de contigüidade.   
Inserção em Pilhas.
O processo e inserção se dá no elemento seguinte ao topo (topo +1 ), sempre que este não ultrapassar a dimensão máxima da lista.

INICIOARGUMENTOSPILHA : MATRIZ [ N ] DE STRING[40]N:INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {O NUMERO DE POSIÇÕES DA PILHA}TOPO:INTEIRO&nbsp; {POSIÇÃO DO PRIMEIRO ELEMENTO DA PILHA}ELEMENTO_NOVO {O NOME A SER INCLUIDO NA PILHA}PROCEDA INSERÇÃO_PILHASE TOPO &gt; = NMOSTRE ( " A PILHA ESTÁ CHEIA ")SENÃOPILHA [ TOPO + 1 ] : = ELEMENTO_NOVOTOPO : = TOPO + 1FIM_SEFIM.   
Remoção em Pilhas.
O processo de remoção em pilha se da no topo da pilha.

INICIOARGUMENTOSPILHA : MATRIZ [ N ] DE STRING[40]N:INTEIRO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {O NUMERO DE POSIÇÕES DA PILHA}TOPO:INTEIRO {POSIÇÃO DO PRIMEIRO ELEMENTO DA PILHA}VARIAVEISPRIMEIRO: STRINGPROCEDA REMOÇÃO_PILHASE TOPO = 0 MOSTRE ( ' A PILHA ESTA VAZIA ")SENÃOPRIMEIRO : = PILHA [ TOPO]PILHA [ TOPO ]&nbsp; : = NULOTOPO : = TOPO - 1RETORNE (PRIMEIRO)FIM_SEFIM.   Recursividade:
Um Algoritmo recursivo é aquele que consiste parcialmente, ou é definido em termos de si próprio.
Tipos de Recursividade:
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Diretamente Recursivo:Quando um algoritmo contiver uma referencia explicita a si mesmo através de seu nome.<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Indiretamente Recursivo:Quando um algoritmo contiver uma chamada a um segundo algoritmo que por sua vez contem uma chamada ao primeiro
Para a criação de algoritmos recursivos devemos levar em conta os seguintes fatores:
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Os algoritmos recursivos deverão sempre ter um nome, pelo qual serão chamados<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Os algoritmos recursivos deverão sempre utilizar argumentos<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Os algoritmos recursivos sempre utilizarão o comando Retorne
O comando retorne é o principal comando dentro de um algoritmo recursivo, pois é através dele que as diversas copias dos algoritmos poderão comunicar-se entre si.
Para que um algoritmo recursivo funcione devemos estabelecer uma condição de parada, que irá disparar um comando retorne que por sua vez irá desencadear uma seqüência de retornos que irá culminar com o encerramento de todas as copias dos algoritmos que estão na pilha.
   
Exemplo de algoritmos recursivos:
Calculo do Fatorial
O calculo do fatorial foi um exercício que já foi feito anteriormente, de forma convencional , vamos apresentar aqui as duas formas, a convencional e a recursiva para que possamos entender melhor como a recursividade funciona.
Convencional:
INICIOARGUMENTONUMERO:INTEIROVARIAVEISFATORIAL : REALPROCEDA FATORIAL_CONVENCIONALFATORIAL=1ENQUANTO NUMERO &gt; 1 FATORIAL : = FATORIAL * NUMERONUMERO : = NUMERO + 1FIM_ENQUANTORETORNE (FATORIAL)FIM
Recursivo:
INICIOARGUMENTONUMERO:INTEIROVARIAVEISFATORIAL : REALPROCEDA FATORIAL_RECSE NUMERO = 1FATORIAL = 1SENÃOFATORIAL = NUMERO * FATORIAL_REC(NUMERO - 1)FIM_SERETORNE (FATORIAL)FIM   
Considerações sobre recursividade:
Antes de Utilizarmos uma solução recursiva para um&nbsp; algoritmo devemos considerar os seguintes pontos:
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Evitar níveis de recursão muito profundos, devido a ocupação de memória.<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->É preferível evitar a recursividade sempre que houver uma solução Convencional<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Nem sempre a solução recursiva é a mais rápida   
Árvores
São estruturas de dados aonde um conjunto de dados é hierarquicamente subordinado a outro.
Comentários.As árvores encontram grande aplicação no processamento de dados pois uma parcela significativa de fenômenos podem ser representados com o seu emprego.Organogramas empresariais são exemplos de árvores, bem como os fluxogramas acadêmicos e árvores genealógicas.A relação de hierarquia expressa através da árvore pode ser uma prioridade , um índice ou outra ascendência qualquer. Algumas estruturas de arquivo tem o seu índice organizado como sendo uma árvore.<!--[if gte vml 1]><v:shape
 id="_x0000_i1034" type="#_x0000_t75" style='width:344.25pt;height:216.75pt'
 o:ole="">  <v:imagedata src="file:///C:\Users\ITALO-~1\AppData\Local\Temp\msohtmlclip1\01\clip_image019.wmz"
  o:title=""/> <![endif]--><!--[if !vml]--><!--[endif]--><!--[if gte mso 9]>  <o:OLEObject Type="Embed" ProgID="MSDraw" ShapeID="_x0000_i1034"
  DrawAspect="Content" ObjectID="_1376409093">   <![endif]-->   
Terminologia.
NÓÉ o dado a partir do qual é definida a hierarquia.Raiz&nbsp;É o nó principal, ou seja, aquele ao qual os demais nós estão subordinados.Sub-ArvoresÉ aquela que se forma a partir de um determinado nó.NívelNumero de "LINHAS" que liga o nó à raiz. A raiz tem nível igual a Zero(0)AlturaA altura de uma árvore corresponde ao seu nível máximo.GrauNumero de Sub - arvores que se formam a partir de um nó.FolhaÉ um nó terminal , isto é , um nó com grau zero(0)FlorestaConjunto de árvores disjuntas.PaiO pai de um nó é aquele ao qual o nó esta diretamente subordinado.IrmãosSão os nós que tem o mesmo pai<!--[if gte vml 1]><v:shape
 id="_x0000_i1035" type="#_x0000_t75" style='width:399pt;height:238.5pt' o:ole="">  <v:imagedata src="file:///C:\Users\ITALO-~1\AppData\Local\Temp\msohtmlclip1\01\clip_image021.wmz"
  o:title=""/> <![endif]--><!--[if !vml]--><!--[endif]--><!--[if gte mso 9]>  <o:OLEObject Type="Embed" ProgID="MSDraw" ShapeID="_x0000_i1035"
  DrawAspect="Content" ObjectID="_1376409096">   <![endif]-->   
Árvore DegeneradaNa pratica se comportam como listas lineares, pois todos os seus nós estão de um mesmo lado.
<!--[if gte vml 1]><v:shape
 id="_x0000_i1036" type="#_x0000_t75" style='width:235.5pt;height:141.75pt'
 o:ole="">  <v:imagedata src="file:///C:\Users\ITALO-~1\AppData\Local\Temp\msohtmlclip1\01\clip_image023.wmz"
  o:title=""/> <![endif]--><!--[if !vml]--><!--[endif]--><!--[if gte mso 9]>  <o:OLEObject Type="Embed" ProgID="MSDraw" ShapeID="_x0000_i1036"
  DrawAspect="Content" ObjectID="_1376409099">   <![endif]-->
Árvores binarias.São estruturas de dados do tipo árvores aonde o grau de um nó é sempre menor ou igual a 2Árvores binarias são o tipo de árvores mais Comumente empregado, devido a sua facilidade de alocação.Para o caso especifico das árvores binarias , faz-se uma diferenciação entre as Sub - arvores da direita&nbsp; e a da esquerda. Isto é:
<!--[if gte vml 1]><v:shape
 id="_x0000_i1037" type="#_x0000_t75" style='width:177.75pt;height:81.75pt'
 o:ole="">  <v:imagedata src="file:///C:\Users\ITALO-~1\AppData\Local\Temp\msohtmlclip1\01\clip_image025.wmz"
  o:title=""/> <![endif]--><!--[if !vml]--><!--[endif]--><!--[if gte mso 9]>  <o:OLEObject Type="Embed" ProgID="MSDraw" ShapeID="_x0000_i1037"
  DrawAspect="Content" ObjectID="_1376409102">   <![endif]-->
Se as árvores acima forem tratadas como árvores binarias, então elas seriam diferentes, caso contrario elas são idênticas ou semelhantes.
Altura de uma árvore binaria completa.
Uma árvore binaria é dita completa quando todos os nós, com exceção das folhas, tem grau igual a 2.Sendo&nbsp; "N" o numero total de nós da árvore, então:
ALTURA =&nbsp; ( Log 2&nbsp;N ) + 1   
Alocação
Via de regra a alocação de árvores se da de forma encadeada, muito semelhante as listas. Na pratica as árvores são alocadas dentro de matrizes, aonde cada registro possui 3 informações:
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O filho da esquerda do nó<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O valor do nó<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O filho da direita do nó
O descritor terá o endereço físico da raiz da árvore.Exemplo:     <!--[if gte vml 1]><v:shape
 id="_x0000_i1038" type="#_x0000_t75" style='width:165.75pt;height:129.75pt'
 o:ole="">  <v:imagedata src="file:///C:\Users\ITALO-~1\AppData\Local\Temp\msohtmlclip1\01\clip_image027.wmz"
  o:title=""/> <![endif]--><!--[if !vml]--><!--[endif]--><!--[if gte mso 9]>  <o:OLEObject Type="Embed" ProgID="MSDraw" ShapeID="_x0000_i1038"
  DrawAspect="Content" ObjectID="_1376409105">   <![endif]-->   

      ESQ      NÓ      DIR  
      2      4      3  
      4      2      5  
      6      6      7  
      -      1      -  
      -      3      -  
      -      5      -  
      -      7      -  
DESCRITOR = 1   
Árvores De Pesquisa Binária(Bst)
Ou BINARY SEARCH TREES (BST), É toda árvores binária aonde as informações contidas em todos os nós respeite as seguintes regras:
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Seja maior do que todas as informações contidas em todos os nós da Sub - arvore da esquerda<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Seja menor que todas as informações contidas em todos os nós da Sub - arvores direita.<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Normalmente não se permite informações iguais em nós diferentes.   
Consulta.
A consulta a uma BST consiste em identificar ou não a existência de um nó correspondente ao argumento de busca, para tanto procedemos da seguinte forma:
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Começamos a busca pela raiz<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Se o nó pesquisado estiver nulo, é porque o argumento não está na árvore.<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Se o argumento de busca for igual ao valor do nó , o processo de busca esta concluído.<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Se o argumento de busca for maior&nbsp; que o valor do nó , a busca continua pela Sub - arvore direita do nó<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Se o argumento de busca for menor do que o nó , então a busca continua pela Sub - arvore esquerda do nó.
INICIO ARGUMENTOS ARVORE : MATRIZ [N] DE REG-ARVOREDESCRITOR:INTEIRON:INTEIROARGUMENTO-DE-BUSCA:INTEIROVARIAVEISREG-ARVORE: REGISTROESQUERDA:INTEIRONO:INTEIRODIREITA:INTEIROFIM-REGISTROCONT:INTEIROPROCEDA CONSULTA-ARVORECONT : = DESCRITORSE&nbsp;&nbsp; CONT&nbsp; = NULOMOSTRE ( "ARVORE VAZIA")SENÃOENQUANTO CONT &lt; &gt; NULOSE ARVORE [CONT ].NO = ARGUMENTO-DE-BUSCARETORNE CONTSENÃOSE ARGUMENTO-DE-BUSCA &gt; ARVORE [CONT ].NOCONT: = ARVORE [CONT ].DIREITAFIM-SESE ARGUMENTO-DE-BUSCA &lt; ARVORE [CONT ].NOCONT: = ARVORE[ CONT ].ESQUERDAFIM-SEFIM-ENQUANTOMOSTRE ("ARGUMENTO NÃO ENCONTRADO")FIM-SEFIM.   Consulta Recursiva
Como nós vamos ver, as arvores binarias tem uma forte natureza recursiva, isto é , devido a sua simetria entre os nós , pode-se fazer o mesmo tratamento para diferentes nós da mesma arvore. Por este motivo&nbsp; podemos escrever todos os algoritmos de tratamento de arvores de forma recursiva, economizando assim linhas de código, e melhorando a performance dos algoritmos.A consulta recursiva tem a mesma estrutura da consulta normal, percorrer a arvore até que seja encontrado o argumento de busca , ou que seja encontrado um elemento nulo, que indica que o argumento pesquisado não se encontra na arvore.
INICIO ARGUMENTOS ARVORE: MATRIZ[N] DE REG-ARVOREN:INTEIRODESCRITOR:INTEIROELEMENTO:INTEIROVARIAVEISREG-ARVORE: REGISTROESQUERDA:INTEIRONO:INTEIRODIREITA:INTEIROFIM-REGISTROPROCEDA CONSULTA-RECSE&nbsp; DESCRITOR = NULORETORNE "ELEMENTO NÃO ENCONTRADO"FIM-SESE ARVORE [ DESCRITOR ].NO = ELEMENTORETORNE DESCRITORSENAOSE ARVORE [ DESCRITOR ].NO &gt; ELEMENTOCONSULTA-REC (ARVORE,N,ARVORE[DESCRITOR].ESQUERDA,ELEMENTO)SENAOCONSULTA-REC (ARVORE,N,ARVORE[DESCRITOR].DIREITA,ELEMENTO)FIM-SEFIM-SEFIM   Inclusão
A inclusão em uma BST permite anexar um novo nó mantendo todas as características da árvore. Para tanto procedemos da seguinte forma:
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Busca-se um registro vazio na matriz, atravessando a árvore pela ordem física. Nesta posição será colocado o novo elemento (pode ser usado o algoritmo de busca do espaço vazio visto anteriormente).<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Procura-se o&nbsp; nó que será pai do incluído (esta busca começa pela raiz)<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Caso exista elemento de igual valor na árvore o procedimento é interrompido.<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Os ponteiros do elemento incluído serão sempre nulos.<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; O ponteiro de seu pai (esquerdo ou direito) deve ser alterado para o endereço físico do elemento que está sendo incluído.
Temos que tomar um cuidado especial se o elemento que vamos incluir é o primeiro da Arvore, pois neste caso teremos que atualizar o descritor   
INICIOARGUMENTOSARVORE: MATRIZ[N] DE REG-ARVOREN: INTEIRODESCRITOR:INTEIROELEMENTO:INTEIROVARIAVEISREG-ARVORE: REGISTROESQUERDA:INTEIRONO:INTEIRODIREITA:INTEIROFIM-REGISTROCONT:INTEIROPAI ,FILHO , POS : INTEIROPROCEDA INCLUSÃO-ARVOREPOS : = ELEMENTO_VAZIO (ARVORE,N)PAI : = NULOFILHO : = DESCRITORENQUANTO FILHO &lt;&gt; NULO E ARVORE [FILHO].NO &lt; &gt; ELEMENTOSE ELEMENTO &gt; ARVORE [FILHO].NO PAI : = FILHOFILHO : = ARVORE[ FILHO ] .DIREITASENAOPAI : = FILHOFILHO : =&nbsp; ARVORE[ FILHO ] .ESQUERDAFIM-SEFIM-ENQUANTOSE ARVORE [ FILHO ].NO = ELEMENTOMOSTRE ( "ELEMENTO JÁ EXISTE")SENÃOARVORE [POS].NO: = ELEMENTOARVORE [POS].DIREITA : = NULOARVORE [POS].ESQUERDA : = NULOSE PAI = NULODESCRITOR : = POSSENÃOSE ARVORE [ PAI ].NO &lt; ELEMENTO ARVORE [ PAI ].DIREITA = POSSENAOARVORE [ PAI ].ESQUERDA = POSFIM SEFIM-SEFIM_SEFIM    Inclusão Recursiva
O processo para inclusão recursiva tem as mesmas diretrizes da inclusão normal, ou seja , eu devo , procurar o locar de inserção do elemento , através de uma pesquisa que começa da raiz, se eu encontrar o elemento, a inclusão deve ser abortada, caso contrario, eu devo fazer a inclusão em um espaço vazio, e fazer com que o respectivo encadeamento do nó incluído com o seu pai. No algoritmo anterior, nós usamos a variável PAI para armazenar que será o pai do novo elemento, no caso do algoritmo recursivo, nós não vamos precisa desta variável, pois o valor do PAI , será armazenado naturalmente na pilha de chamadas.   
INICIO ARGUMENTOS ARVORE,N,DESCRITOR,ELEMENTO,INCVARIAVEISN,DESCRITOR,ELEMENTO : INTEIROINC:LOGICOREG-ARVORE: REGISTROESQUERDA:INTEIRONO:INTEIRODIREITA:INTEIROFIM-REGISTROMATRIZ ARVORE[N] DE REG-ARVOREPROCEDA INCLUSAO-RECSE&nbsp; DESCRITOR = NULOINCLUIU : = VERDADEIROPOS : = ELEMENTO-VAZIO(ARVORE,N)ARVORE [ POS ].NO : = ELEMENTOARVORE [ POS ].ESQUERDA : = NULOARVORE [ POS ].DIREITA : = NULOSENAOSE ARVORE [ DESCRITOR ] = ELEMENTORETORNE "INCLUSAO INVALIDA")FIM-SESE ARVORE [ DESCRITOR ].N &gt; ELEMENTOINCLUSAO-REC (ARVORE,N,ARVORE[DESCRITOR].ESQUERDA,ELEMENTO,INC)SE INCARVORE [ DESCRITOR ] . ESQUERDA : = POSINC : = FALSOFIM-SESENAOCONSULTA-REC (ARVORE,N,ARVORE[DESCRITOR].DIREITA,ELEMENTO,INC)SE INCARVORE [ DESCRITOR ].DIREITA : = DESCRITORINC: = FALSOFIM-SEFIM-SEFIM-SESE INC DESCRITOR : = POSFIM-SEFIM Exclusão
A exclusão permite eliminar um nó de uma árvore mantendo suas propriedades. Para tanto&nbsp; procedemos da seguinte forma, a exclusão será feita somente de maneira recursiva, pois a sua implementação de forma normal é muito complicada.
<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Procura-se o no que vai ser excluído e o seu pai<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Se o nó que será excluído não tiver nenhum filho ele será simplesmente excluído<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Se o nó que será excluído tiver somente um filho o seu avo passará a ser o seu pai.<!--[if supportFields]><span
style='font-size:12.0pt;mso-bidi-font-size:10.0pt'><span style='mso-element:
field-begin'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<span
style='mso-element:field-separator'><![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp;&nbsp; Se o no a ser excluído tiver 2 filhos ele será substituído pelo nó que estiver mais a esquerda entre todos os que estão a sua direita.
Novamente devemos tomar um cuidado espcia caso se faça a exclusão da raiz da arvore, neste caso teremos que atualizar o descritor.   INICIOARGUMENTOSARVORE,N,DESCRITOR,ELEMENTOVARIAVEISREG-ARVORE: REGISTROESQUERDA:INTEIRONO:INTEIRODIREITA:INTEIROFIM-REGISTRON,DESCRITOR,ELEMENTO,FILHO,PAI,NP:INTEIROMATRIZ ARVORE[N] DE REG-ARVOREPROCEDA EXCLUSÃO-ARVOREFILHO : =DESCRITORPAI : =DESCRITORENQUANTO ARVORE[ FILHO ].NO &lt; &gt; ELEMENTO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; E ARVORE [ FILHO ].NO &lt; &gt; NULOPAI : = FILHO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {PROCURA O NO}SE ELEMENTO &gt; ARVORE&nbsp; [ FILHO ].NOFILHO : = ARVORE [ FILHO ].DIREITASENAO FILHO : = ARVORE [ FILHO ].ESQUERDAFIM-SEFIM ENQUANTOSE ARVORE&nbsp; [ FILHO ].NO = NULORETORNE "ERRO ELEMENTO INEXISTENTE"FIM-SESE ARVORE [ FILHO ].ESQUERDA = NULO E ARVORE [ FILHO ] .DIR = NULO SE ARVORE [ FILHO ].NO &gt; ARVORE [ PAI ].NOARVORE [ PAI ].DIREITA : = NULOSENAO&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {CASO O NO SEJA FOLHA}ARVORE [ PAI ].ESQUERDA : = NULOFIM-SESENAOSE ARVORE [ FILHO ].ESQUERDA &lt; &gt; NULO &nbsp; E ARVORE [ FILHO ].DIREITA &lt; &gt; NULONP : = ARVORE [ FILHO ] .DIREITAENQUANTO&nbsp; ARVORE [ NP ].ESQUERDA &lt; &gt; NULONP : = ARVORE [ NP ].ESQUERDAFIM_ENQUANTOEXCLUSAO-ARVORE (ARVORE,N,DESCRITOR,ARVORE [NP].NO)ARVORE [ FILHO ].NO : = ARVORE [NP].NOSENAOSE ARVORE [ FILHO ].NO &gt; ARVORE [ PAI ].NOARVORE [ PAI ].DIREITA : = ARVORE [ FILHO ].DIREITASENAOARVORE [ PAI ].ESQUERDA : = ARVORE [FILHO].ESQUERDAFIM-SEFIM-SEFIM-SEFIM

Atravessamento
É a operação de percorrer os nós de uma árvore de forma sistemática, visitando cada nó uma única vez. Existem 3 formas de atravessamento:
<!--[if supportFields]><b
style='mso-bidi-font-weight:normal'><span style='font-size:12.0pt;mso-bidi-font-size:
10.0pt'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp; Atravessamento Pre-Fixado<!--[if supportFields]><b
style='mso-bidi-font-weight:normal'><span style='font-size:12.0pt;mso-bidi-font-size:
10.0pt'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp; Atravessamento Pós-Fixado<!--[if supportFields]><b
style='mso-bidi-font-weight:normal'><span style='font-size:12.0pt;mso-bidi-font-size:
10.0pt'>SYMBOL 183 \f &quot;Symbol&quot; \s 10 \h<![endif]--><!--[if supportFields]><span
style='mso-element:field-end'><![endif]-->&nbsp;&nbsp;&nbsp; Atravessamento em ordem.
Os três algoritmos de atravessamento serão feitos de maneira recursiva, devido ao fato dos algoritmos convencionais serem muito complexos
Atravessamento em ordem.
Requer que se desça pelo no raiz , sempre pela esquerda até que não seja mais possível. Então&nbsp; mostra-se o nó. Ai vai-se um no para direita&nbsp; e recomeça o processo.
INICIOARGUMENTOSARVORE : MATRIZ [ N ] DE REG-ARVOREN:INTEIRODESCRITOR:INTEIROVARIAVEISREG-ARVORE: REGISTROESQUERDA:INTEIRONO:INTEIRODIREITA:INTEIROFIM-REGISTROPROCEDA ATRAV-ARVORESE DESCRITOR &lt; &gt; NULOATRAV-ARVORE(ARVORE,N,ARVORE [ DESCRITOR ].ESQUERDA)MOSTRE (ARVORE [ DESCRITOR ].NO)ATRAV-ARVORE(ARVORE,N,ARVORE [ DESCRITOR ].DIREITA)FIM-SEFIM.   Atravessamento Pre-Fixado
Para se fazer o atravessamento pré - fixado, devemos primeiramente mostrar o nó , e então atravessar toda a sua Sub - arvore de esquerda, e depois toda a sua Sub - arvore da direita. Neste caso a raiz será o primeiro nó a ser mostrado , e as informações não serão apresentadas em ordem crescente.
INICIOARGUMENTOSARVORE: MATRIZ [ N ] DE REG-ARVORE N: INTEIRODESCRITOR: INTEIROVARIAVEISREG-ARVORE: REGISTROESQUERDA:INTEIRONO:INTEIRODIREITA:INTEIROFIM-REGISTROPROCEDA ATRAV-ARVORE-PRESE DESCRITOR &lt; &gt; NULOMOSTRE (ARVORE [ DESCRITOR ].NO)ATRAV-ARVORE-PRE(ARVORE,N,ARVORE [ DESCRITOR ].ESQUERDA)ATRAV-ARVORE-PRE(ARVORE,N,ARVORE [ DESCRITOR ].DIREITA)FIM-SEFIM.
   Atravessamento Pos-Fixado
Para se fazer o atravessamento pós - fixado nós devemos primeiro atravessar toda a Sub - arvore da esquerda de um nó, depois toda a Sub - arvore da direita , e só então mostrar o nó.Neste caso , a raiz será o ultimo nó a ser mostrado, e as informações não estarão em ordem crescente.
INICIOARGUMENTOSARVORE : MATRIZ [ N ] DE REG-ARVOREN:INTEIRODESCRITOR : INTEIROVARIAVEISREG-ARVORE: REGISTROESQUERDA:INTEIRONO:INTEIRODIREITA:INTEIROFIM-REGISTROPROCEDA ATRAV-ARVORE-POSSE DESCRITOR &lt; &gt; NULOATRAV-ARVORE-POS(ARVORE,N,ARVORE [ DESCRITOR ].ESQUERDA)ATRAV-ARVORE-POS(ARVORE,N,ARVORE [ DESCRITOR ].DIREITA)MOSTRE (ARVORE [ DESCRITOR ].NO)FIM-SEFIM.

   
Pesquisa
É o processo ordenado de busca a um conjunto de informações que atendam a uma condição lógico relacional.
Exemplo:
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Lista Telefônica.
Dependendo dos recursos disponíveis e da maneira com as informações estão dispostas, poderemos optar por diferentes métodos de pesquisa:
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Pesquisa Seqüencial<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Pesquisa Binaria<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Pesquisa Por Endereçamento Direto<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Pesquisa por Endereçamento Indireto.   
Pesquisa seqüencial:
É o mais simples dos métodos de pesquisa.O conjunto de informações a ser pesquisado pode estar apresentado em qualquer ordem , ou mesmo sem ordem.Consiste em uma varredura de todas as informações do conjunto até que :
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Encontremos a informação desejada, <!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Ou que não existam mais informações a serem pesquisadas.
A pesquisa seqüencial tem as seguintes características:
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Simples<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Pouco Eficaz<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Único método disponível em dispositivos de acesso seqüencial (fita magnética)<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Independe da ordem na qual as informações estão expressas<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Recomendado para pequenos vetores(menor ou igual a 100 elementos)
ALGORITMO DE PESQUISA SEQUENCIAL
INICIOARGUMENTOSNUMEROS : MATRIZ [N] DE INTEIROSN:INTEIROELEMENTO_PRO:INTEIROVARIAVEIS:POS:INTEIROPROCEDA PESQUISA_SEQUENCIALCONT : = 1ENQUANTO CONT &lt; = NSE NUMEROS [CONT] = ELEMENTO_PRORETORNE [CONT]FIM_SECONT : = CONT + 1FIM_ENQUANTOMOSTRE (“ARGUMENTO NÃO ENCONTRADO”)FIM.
   
Pesquisa binaria:
A pesquisa binaria é um dos mais eficientes métodos de pesquisa, porem exige que as informações a serem pesquisadas estejam classificadas.
Supondo que a classificação seja em ordem crescente, procedesse da seguinte forma:
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Para a pesquisa trabalha-se com dois limites, o superior e o inferior.<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->O limite inferior a ser pesquisado corresponde a primeira informação do vetor<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->O limite superior corresponde a ultima informação do vetor.<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->A pesquisa e sempre feita para a média:Média = (Limite inferior + Limite superior) / 2<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Se a informação pesquisada estiver acima da média, o limite inferior passa a ser a média +1<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Se a informação buscada estiver abaixo da média, o limite superior passa a ser a média - 1
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Este processo se completa quando :<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->A informação pesquisada é encontrada,<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Ou o limite inferior é maior que o limite inferior, neste caso o argumento não existe no conjunto pesquisado.
Características:
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Muito Eficaz<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Fácil entendimento<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Não funciona em dispositivos de acesso seqüencial<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Só funciona se as informações estiverem ordenadas
   
Pesquisa Binaria:
ALGORITIMO DE PESQUISA BINARIA:
INICIOARGUMENTOSNUMEROS:MATRIZ [N] DE INTEIROSN:INTEIROELEMENTO_PRO:INTEIROVARIAVEISPOS:INTEIROSSUP,INF,MED:INTEIROSPROCEDA PESQUISA_BINARIASUP: =NINF: =1REPITAMED: = TRUNCA((SUP+INF) / 2)CASOELEMENTO_PRO &gt; NUMEROS [MED]INF: = MED + 1ELEMENTO_PRO &lt; NUMEROS [MED]SUP: = MED - 1ELEMENTO_PRO = NUMERO [MED]RETORNE(MED)FIM_CASOATE INF &gt; SUPFIM_REPITAMOSTRE (“ARGUMENTO NÃO ENCONTRADO”)FIM   
Pesquisa por Endereçamento Direto:
É um dos mais fáceis métodos de pesquisa, para tanto , o argumento de pesquisa deve ser equivalente ao numero da linha que a informação ocupa dentro do vetor..
Este método de pesquisa possui dois inconvenientes:
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->O argumento de pesquisa deve ser numérico.<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->A área de memória alocada a sua disposição é quase sempre super dimensionada.
Características:
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Muito Simples<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Pouco eficaz<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Só funciona em dispositivos de acesso direto.<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Depende da equivalência do argumento de pesquisa com a posição física do elemento.<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Tempo de acesso praticamente instantâneo.<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Muito dispersivo na ocupação de memória
Pesquisa por Endereçamento Indireto (Hashing)
Suponha que você tenha um código formado por três números inteiros, usados como argumento de busca. Se fossemos utilizar o endereçamento direto, teríamos um vetor de 999 posições.
Suponha que destes 999 códigos possíveis, apenas 52 seriam utilizados efetivamente. Uma vez que o desperdício de memória vai ser grande , fazemos uma adaptação ao método de endereçamento direto, através da adoção de uma função que damos o nome de função de transformação.
O ideal é que esta função gere o menos numero de colisões possíveis.
Chama-se colisão a particularidade que permite que dois argumentos de busca , diferentes, terem o mesmo endereço físico a partir da função de transformação.
Uma boa função de transformação é:
Endereço físico = (resto (argumento/X)+1)
Aonde X é o primeiro numero primo imediatamente acima da quantidade de informações efetivas.
Controlando as Colisões:
Caso aconteça que dois argumentos de busca tenham o mesmo endereço físico, então o segundo argumento é colocado no próximo endereço físico livre , após a colisão, encadeando-se os ponteiros do vetor.   
Classificação :
A classificação ou ordenação de dados é uma das tarefas mais usuais no funcionamento dos sistemas. Alguns métodos de pesquisa exigem que o conjunto de dados a ser pesquisado esteja classificado de acordo com uma ordem conhecida. Também, grande parte dos relatórios necessita de informações classificadas de acordo com uma ordem pré-determinada.
É aconselhável que a classificação fique restrita a um mínimo necessário por duas razões:
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Absorve grande quantidade de memória secundaria(disco)<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->É uma tarefa muito demorada
A ordenação física de um arquivo é dividida em duas etapas:
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Classificação Interna:O arquivo é carregado em partes na memória principal, cada parte é então classificada sendo o seu resultado devolvido a memória secundaria.
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->Classificação Externa:Nesta etapa os blocos ordenados são fundidos em um só arquivo, agora totalmente classificado.
Dentre os métodos mais comuns de classificação interna, estudaremos 2 famílias:
<!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->A classificação por troca <!--[if !supportLists]-->·&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <!--[endif]-->E a por inserção   
Classificação por Inserção
Método da Inserção Direta
A característica deste método é que o vetor a ser classificado fica sempre dividido em dois segmentos.O primeiro segmento, inicialmente contem somente o primeiro elemento da lista, estando portanto classificado.O segundo segmento da lista , inicialmente contem todos os outros elementos do vetor.A partir de então todos os elementos do segundo segmento são incluídos no primeiro ,um a um, de forma que o primeiro segmento esteja sempre classificado. O processo termina quando não existirem mais elemento no segundo segmento.
INICIOARGUMENTOSNUMEROS: MATRIZ [N] DE INTEIROSN:INTEIROVARIAVIESCONT,DIV:INTEIROSPROCEDA INSERCAO_DIRETADIV : = 1REPITAELEMENTO: = NUMEROS [DIV + 1]CASO ELEMENTO=NUMEROS[DIV]DIV : = DIV + 1ELEMENTO &gt; NUMEROS[DIV]DIV: = DIVI + 1ELEMENTO &lt;&nbsp; LISTA[DIV]CONT : = DIVENQUANTO ELEMENTO&lt; NUMEROS[CONT] E CONT &gt; 0NUMEROS [CONT + 1]: =NUMEROS [CONT]NUMEROS [ CONT]) : = ELEMENTOCONT&nbsp; : =&nbsp; CONT +1FIM_ENQUANTODIV: = DIV + 1FIM_CASOATE DIV = NFIM_REPITAFIM   
Classificação por Troca
Método da Bolha (Bubble)
Neste método cada elemento é comparado com o seu sucessor, e se o elemento for maior que o seu sucessor eles trocam de posição.
O processo de troca atravessa todo o vetor.
A classificação fica concluída quando em um atravessamento não for executada nenhuma troca.
INICIOARGUMENTOSNUMEROS : MATRIZ [N] DE INTEIROSN:INTEIROVARIAVEISPOS: INTEIRO AUX:INTEIROPROCEDA BUBBLE_SORTREPITATROCA : = FALSOPOS : = 1ENQUANTO POS &lt;&nbsp; N SE NUMEROS [ POS ]&nbsp; &gt;&nbsp; NUMEROS [ POS + 1 ]AUX: = NUMEROS [ POS + 1 ]NUMEROS [ POS + 1 ] : = NUMEROS [ POS ]NUMEROS [ POS ] : = AUXTROCA : = VERDADEIROFIM_SE POS : = POS + 1FIM_ENQUANTOATE TROCA = FALSOFIM_REPITAFIM   Método da Troca e de Partição(Quick Sort)
Foi proposto por C.A. Hoare em 1962 e é considerado como o mais rápido em relação aso métodos apresentado anteriormente.O método adota como principio que é mais fácil e rápido classificar 2 vetores com N/2 elementos cada um , do que um único vetor com N elementos.O Quick Sort funciona de dividindo o vetor em duas partes,e tendo um elemento central no meio do vetor. Deposi disso é&nbsp; movimentando para a primeira parte os elementos menores que o elemento central e para a segunda parte os elementos maiores que o elemento central.Depois disso , o processo se repete para as partes 1 e 2 do vetor original, e assim consecutivamente até o vetor esta completamente classificado.
INICIOARGUMENTOSVETOR : MATRIZ [N ] DE INTEIROSESQ:INTEIRODIR:INTEIROVARIAVEISI:INTEIROJ:INTEIROTRAB:INTEIROAUX:INTEIROPROCEDA QUICKSORTI : = ESQJ : = DIRTRAB : = VETOR [ TRUNCA((ESQ + DIR) / 2) ]REPITAENQUANTO VETOR [ I ] &lt; TRABI : = I + 1FIM_ENQUANTOENQUANTO VETOR [ J ] &lt; TRABJ : = J - 1FIM_ENQUANTOSE&nbsp; I &lt; = JAUX : = VETOR [ I ] VETOR [ I ] : = VETOR [ J ] VETOR [ J ] : = AUXI : = I + 1J : = J – 1FIM_SEATE I&nbsp; &gt; JFIM_REPITASE L &lt;&nbsp; JQUICKSORT( L , J )FIM_SESE I &lt; J QUICKSORT( I , R )FIM_SEFIM.