UNICARIOCA

ESTRUTURA DA INFORMAÇÃO
NOTAS DE AULA
Manuel

1- TIPOS DE ESTRUTURAS DE DADOS

1.1- LISTAS LINEARES

1.1.1- MOTIVAÇÃO

Tipo de estrutura usada na solução de problemas que envolvem conjuntos de dados que se
relacionam mantendo uma relação de ordem.

Exemplo: Agenda Telefônica:

Os elementos de uma agenda são fichas com Nome, Endereço, e Telefone , organizadas em
ordem alfabética. Tomando-se o devido cuidado quando da inserção de novas fichas, ou seja,
respeitando-se a ordem alfabética, pode-se facilmente acessar o dado desejado sempre que for
necessário. Como fichas podem ser inseridas ou removidas, o tamanho da agenda (nº de
fichas) é variável ao longo do tempo.

1.1.2 - CONCEITUAÇÃO

Lista - É a estrutura que permite representar um conjunto de dados de forma a preservar a

relação de ordem entre eles. Uma lista é composta de nós (registros), sendo que cada nó
pode conter um dado primitivo ou um dado composto.

EX-1: Uma lista com as taxas mensais de inflação nos últimos 24 meses. (Dado simples)
Ordenação: Mês/Ano

EX-2: Uma lista com Nome e Matrícula dos alunos de uma escola. (Dado composto)
Ordenação: Matrícula.

Ex-3: Uma lista com Nome e Salário dos deputados estaduais do Estado do Rio de Janeiro.
Qual seria a melhor ordenação neste caso ?

DEF: Lista é uma coleção ordenada de componentes do mesmo tipo. Tipicamente este é o
tipo registro (record);

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 1 MANUEL

DEF FORMAL: Lista é um conjunto de n nós x1, x2, ........., xn organizados estruturalmente de
forma a refletir as posições relativas dos mesmos.

. Se n > 0
. x1 é o primeiro nó
. Para 1 < k < n.
xk é precedido pelo nó xk-1 e seguido pelo nó xk+1.
. Se n=0 a lista é vazia.

Representação Física

L = {x1,x2,x3,.......,xn}  Lista com n nós.

INÍCIO  CRIAÇÃO DA LISTA

NÓ-1 NÓ-2 NÓ-3 NÓ-N

X1 X2 X3 ...... Xn
INFO ELO INFO ELO INFO ELO INFO ELO

INFO - INFORMAÇÃO / ELO - ENDEREÇO DO PRÓXIMO NÓ

1.1.3 - PRINCIPAIS OPERAÇÕES SOBRE LISTAS

1 - Acessar o k-ésimo nó da lista para obter e/ou alterar o dado nele contido.

2 - Inserir um novo nó antes ou após o k-ésimo nó da lista.

3 - Remover o k-ésimo nó da lista.

4 - Concatenar duas listas.

5 - Determinar o número de nós de uma lista.

6 - Localizar o nó que contém um dado valor.

1.1.4-FORMAS DE REPRESENTAÇÃO

Existem várias formas de representar internamente uma lista no computador. Obviamente, a

escolha da representação mais adequada depende não só dos tipos de operações que se
deseja executar sobre a lista, como também, da freqüência com que estas operações serão
realizadas. Determinadas representações são mais favoráveis a algumas operações, enquanto
outras não o são, no sentido de exigir uma maior esforço computacional para a sua execução.

As principais formas de representação são:

- Por contiguidade (Lista seqüencial)

- Por encadeamento (Lista Ligada)

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 2 MANUEL

POR CONTIGUIDADE

Características:

- Explora a seqüencialidade da memória do computador.

- Os nós (registros) são armazenados em endereços contíguos (lado a lado).

- Relação de ordem: se o endereço do nó xk é conhecido, o endereço do nó xk+1 pode ser

determinado.

Implementação

A maneira mais singela (simples) e obvia de implementar uma lista em computador é através
da utilização de um vetor. Esta representação é bastante satisfatória para algumas operações e
bastante ineficiente para outras. Ela é utilizada em situações em que as inclusões/exclusões
são realizadas sempre no final da lista (não são necessárias inclusões/exclusões em posições
intermediárias). Apresenta-se a seguir, vantagens e desvantagens da implementação de uma
lista em um vetor.

Vantagens:

- Pode-se facilmente alterar ou determinar o valor de um dado.

EX-1 : Suponha uma lista implementada no vetor Vet [1..200] com valores inteiros (Integer).

Para alterar o valor do nó 10 para 236 basta fazer:

Vet[10] := 236; ou

Para determinar, por exemplo, o conteúdo do nó-2.

Writeln( Vet[2] );

EX-2 : Suponha uma lista com nome e telefone implementada no vetor Item.
Para acessar o nó 20 e determinar o seu conteúdo basta fazer:

Writeln( Item[20].Nome );

Writeln( Item[20].Telefone );

Para alterar o nó 3 basta fazer:

Item[3].Nome := ‘Acyr Magno’ ;

Item[3].Telefone := ‘2216014’ ;

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 3 MANUEL

Desvantagens:

1- É preciso especificar antecipadamente a dimensão máxima do vetor onde a lista vai ser
implementada.

Exemplo-1:

Var Item: Array [1..N_Max] of Lista ;

Onde N_Max é a dimensão máxima da lista.

2- Inserções e remoções podem exigir considerável movimentação de dados.

Exemplo-2: Suponhamos uma lista com Nome e CPF implementada no vetor Reg com
dimensão máxima (N_Max = 2.000) e com 800 nós. Desejamos inserir um novo (nó) na
posição 4 da lista. Qual o procedimento padrão supondo que a lista já esta montada?

Temos:

antes 1 2 3 4 5 6 ................... 797 798 799 800

depois 1 2 3 * 5 6 7 ................... 798 799 800 801

O NÓ 4 RECEBE O NOVO NOME E O NOVO CPF

Program Inclui_Dado;

Const N_Max = 2000;

Type Lista = Record

Nome : String[30];
CPF : String[11];
end;

Var Reg : Array [1..N_Max] of Lista;

I, N_Lista : Integer;

Begin
for I := 800 Downto 4 do
Reg[I+1] := Reg [I];
Reg [ 4 ].Nome := ‘Novo Nome’ ;
Reg [ 4 ].CPF := ‘Novo CPF’;
N_Lista := 801;
End.

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 4 MANUEL

Definições para Implementação (PASCAL)

Consideremos a seguinte Lista (L)

x1 x2 x3 ............
01 02 03 DIM

DESCRITORES DA LISTA (DEFINEM O ESTADO DA LISTA)

INI = 01 - INÍCIO DA LISTA (POSIÇÃO DO PRIMEIRO NÓ)

FIM = 03 - DEFINE O FIM DA LISTA (POSIÇÃO DO ÚLTIMO NÓ)
COR = 00 - NÓ CORRENTE DA LISTA (PERMITE PERCORRER A LISTA)
NUM= 03 - NÚMERO DE ELEMENTOS DA LISTA (NÚMERO DE NÓS)

NÓS DA LISTA (elementos)

INI FIM COR NUM
 DESCRITORES  DIM

Informações(INFO)

DIM é a dimensão do vetor onde está implementada a lista.

Assim uma Lista ( L ) = Descritores + Nós (Informações)

Os Descritores definem as características da Lista, ou seja, início, fim, número de

elementos, e finalmente o nó corrente.

Os nós ou elementos da Lista, contém os dados propriamente ditos (as informações - INFO).
Cada elemento por sua vez, é composto de duas partes básicas: a Chave e o Conteúdo.

Esquematicamente tem-se:

Elemento (Nó) Chave Conteúdo

Chave - é uma informação normalmente utilizada para classificação e/ou pesquisa.

Conteúdo - são as informações (dados) que se deseja armazenar.

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 5 MANUEL

Genericamente define-se assim uma Lista:

(Definição da Lista - Pascal)

Const
Dim = 100;

Type Tipo_Chave = record

Matr : String [10];
end;

Tipo_Elemento = record
Chave : Tipo_Chave;
Conteudo: String [30];
end;

Tipo_Lista = record
Ini : Integer;
Fim : Integer;
Cor : Integer; { * DESCRITORES * }
Num : Integer;
Elemento : Array [1..Dim] of Tipo_Elemento; {Info}
end;

{ Declaração das Variáveis }

Var
L : Tipo_Lista; { L = Lista}
X,W : Tipo_Elemento; {Elemento da Lista-Informações}
Cr : Integer; {Código de retorno}

Obs.: Cr = 0  operação com sucesso

Cr <> 0  operação sem sucesso

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 6 MANUEL

Exercício-1: Deseja-se armazenar as seguintes informações referentes a 1000 alunos: Nome,
Matrícula, Data Nascimento, Endereço, e Telefone. As informações devem ser armazenadas
por ordem crescente de Matrícula. Defina a estrutura de dados para este problema, sabendo
que:

Matr - String [11]

Nome - String [ 30 ]
D_Nasc - String [8]
Ender - String [ 45 ]
Telefone - String [ 10 ]

Solução:

{ Definição da Estrutura de Dados - Lista }

Const Dim = 1000;

Type Tipo_Chave = Record

Matr : String[11];
end;

Tipo_Elemento = Record
Chave : Tipo_Chave;
Nome : String [ 30 ];
D_Nasc : String [ 8 ];
Ender : String [ 45 ];
Tel : String [ 10 ];
end;

Tipo_Lista = Record
Ini : Integer;
Fim : Integer;
Cor : Integer;
Num : Integer;
Elemento : Array [ 1..Dim ] of Tipo_Elemento;
end;

Var L : Tipo_Lista { L = Lista}

W,X : Tipo_Elemento; { W,X = Elementos da Lista }
CR : Integer; { Código de Retorno }

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 7 MANUEL

POR ENCADEAMENTO

Característica: Cada elemento é associado a outro através de um ponteiro (elo de ligação).

Assim, quando é necessário se fazer uma inclusão ou exclusão de um elemento em uma
posição intermediária, não é preciso deslocar os demais elementos de suas posições
originais, basta que se atualize os ponteiros. Para grandes conjuntos de dados consegue-se
maior rapidez de processamento nas operações realizadas com os mesmos.

Fig.1

INÍCIO  CRIAÇÃO DA LISTA

NÓ-1 NÓ-2 NÓ-3 NÓ-N

X1 X2 X3 ............... Xn
INFO ELO INFO ELO INFO ELO INFO ELO

INFO - INFORMAÇÃO / ELO - ENDEREÇO DO PRÓXIMO NÓ

Neste tipo de representação, a sequencialidade é preservada de uma forma lógica, e não de

uma forma física. Assim, pode-se ter várias ordenações distintas para os elementos de uma
Lista. Para isto, basta que sejam criadas diferentes seqüências de ponteiros, (diferentes
conteúdos do vetor ELO) cada uma das seqüências corresponderá a uma ordenação diferente.

Fig.2

NO-1 NÓ-2 NÓ-3 NÓ-4

X3 2 X4 0 X1 4 X2 1
INFO ELO INFO ELO INFO ELO INFO ELO

Seqüencialidade Lógica - (Não Física)

Com uma pequena dose de abstração, um mínimo de criatividade, e uma razoável linguagem
de programação, pode-se fazer uma boa utilização do conceito de Lista para resolver
problemas práticos.

Algumas linguagens oferecem recursos de alocação dinâmica (pointers, etc), o que facilita a
implementação das operações sobre Lista Encadeadas. Para as linguagens que não oferecem
este tipo de recurso, usa-se o Encadeamento Simulado que será visto a seguir.

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 8 MANUEL

ENCADEAMENTO SIMULADO

Exemplo:

INFO X3 X4 X1 X2
ELO 02 00 05 00 01
01 02 03 04 05

INI = 03 (APONTA PARA A PRIMEIRO)

FIM = 02 (APONTA PARA O ÚLTIMO)
LIV = 04 (APONTA PARA O PRÓXIMO LIVRE)
COR = 00 (APONTA PARA O CORRENTE)
ANT = 00 (APONTA PARA O ANTERIOR - LISTA DUPLAMENTE ENCADEADA)
NUM = 04 (NÚMERO ATUAL DE ELEMENTOS)

(Definição da Lista)

Const
Dim = 100;
Type Tipo_Elemento = record
Chave : Tipo_Item_Chave;
Conteúdo: String;
end;

Tipo_Lista = record
Ini : Integer; { DESCRITORES }
Fim : Integer;
Liv : Integer;
Cor : Integer;
Ant : Integer;
Num: Integer;
Elemento: Array [1..Dim] of Tipo_Elemento; {INFO}
Elo : Array [1..Dim] of Integer; {ELOS-PONTEIROS}
end;

{Declaração das Variáveis}

Var
L : Tipo_Lista; {L = Lista}
X,W : Tipo_Elemento; {Elemento da Lista-Informações}
Cr : Integer; {Código de retorno}

É importante observar que, a implementação das operações de inclusão e exclusão na

representação por Encadeamento Simulado, requer necessariamente, que seja feito um
gerenciamento das áreas livres (nós livres). Neste caso, o método utilizado é o de uma
“Pilha” de áreas livres, que será visto a partir da Lista de Exercícios - 05.

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 9 MANUEL

1.1.5 - Operações Básicas - Alocação Contígua

a. Criação da Lista - Cria uma Lista vazia.

Procedure Cria_Lista (var L : Tipo_Lista);

begin
L.Ini := 0; L.Fim := 0; L.Cor:= 0; L.Num := 0;
end;

b. Verificação

b.1 Lista Vazia - Retorna (TRUE) se Lista vazia.

Function Lista_Vazia (L:Tipo_Lista) : Boolean;

begin
if L.Num = 0 { Testa se o no. de elementos de L = 0}
then Lista_Vazia := true
else Lista_Vazia := false;
end;

b.2 Lista Cheia - Retorna (TRUE) se Lista cheia.

Function Lista_Cheia (L:Tipo_Lista) : Boolean;

begin
if L.Num = Dim {Testa se o no.de elementos de L = Dim}
then Lista_Cheia := true
else Lista_Cheia := false;
end;

c. Acesso sequencial

c.1 Primeiro Elemento da Lista-Posiciona no 1º elemento da Lista e retorna seu conteúdo em X.

Procedure Prim_Corr (var L:Tipo_Lista; var X: Tipo_Elemento; var CR:Integer);

begin
if Lista_Vazia(L)
then begin
CR := 2; {CR = 2 Lista Vazia}
X.Chave:= “ “;
end
else begin
CR := 0;
L.Cor : =L.Ini;
X.Chave := L.Elemento[L.Cor].Chave;
X.Conteudo := L.Elemento[L.Cor].Conteudo;
end;
end;

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 10 MANUEL

c.2 Próximo elemento da Lista - Posiciona no próximo elemento e retorna seu conteúdo em X.

Procedure Prox_Corr (var L:Tipo_Lista;var X: Tipo_Elemento;var CR:integer);

begin
if L.Cor = 0 or L.Cor = L.Fim
then begin
CR := 2; {Não há corrente ou fim da lista}
X.Chave:= “ ”;
end
else begin
CR :=0;
L.Cor := L.Cor + 1;
X.Chave := L.Elemento [ L.Cor ].Chave;
X.Conteudo := L.Elemento [ L.Cor ].Conteudo;
end;
end;

d. Acesso por valor

d.1 Procura o elemento com valor da Chave igual a V (Chave) e retorna seu conteúdo em X.

Procedure Acha_Val (var L:Tipo_Lista;var V:Tipo_Item_Chave;

var X:Tipo_Elemento;var CR: Integer);
begin
CR := 2;
Prim_Corr(L,X,Cod);
While (Cod=0 and CR < > 0) do
begin
if X.Chave=V
then CR := 0
else Prox_Corr(L,X,Cod);
end;
end;

e. Inclusão/Alteração

e.1 Inclui elemento X no final da Lista

Procedure Inclui_Fim(var L:Tipo_Lista;var X:Tipo_Elemento;var CR:Integer);

begin
it Lista_Cheia(L)
then CR := 4 {Lista Cheia }
else begin
CR := 0;
L.Fim := L.Fim + 1;
L.Elemento [L.Fim ].Chave := X.Chave;
L.Elemento [L.Fim]. Conteudo := X.Conteudo;
if L.Num = 0 {Se a lista estiver vazia}
then L.Ini := L.Fim; {atualiza os descritores}
L.Num := L.Num + 1;
end;
end;

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 11 MANUEL

e.2 Inclui elemento X no elemento corrente da Lista

Procedure Inclui_Corr (var L:Tipo_Lista; var X:Tipo_Elemento; var CR:Integer);

var I : Integer;
begin
if Lista_Cheia ( L )
then Cr := 4 {Lista Cheia}
else begin
if L.Cor = 0 {Lista vazia ou fim da lista}
then Inclui_Fim (L,X,Cod)
else begin
for I := L.Fim Downto L.Cor do
begin
L.Elemento [ I + 1]:= L.Elemento [ I ];
end;
L.Elemento [L.Cor].Chave := X.Chave;
L.Elemento [L.Cor].Conteudo :=X.Conteudo;
L.Fim := L.Fim + 1;
L.Num := L.Num + 1;
end;
end;
end;

e.3 Inclui elemento X ordenadamente na Lista sem permitir duplicatas.

(Pesquisa para saber onde incluir)

Procedure Inclui_Ord(var L:Tipo_Lista;var X:Tipo_Elemento;var CR:Integer);

var Siga : Boolean;

Begin
CR := 0;
Siga := true;
Prim_Corr ( L,W,Cod); {Posiciona no 1º elemento da Lista}
While (Cod=0 and Siga) do { Início do While }
begin
if W.Chave = X.Chave
then begin
Siga := false;
CR := 6; {Já existe na Lista}
end
else begin
if W.Chave > X.Chave
then Siga := False
else Prox_Corr (L,W,Cod);
end;
end; { Fim do While }

if CR = 0 {Não encontrou X.Chave antes do Corrente}

then Inclui_Corr (L,X,CR);

end; {Fim da Procedure}

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 12 MANUEL

e.4 Altera os campos do elemento corrente (Incrementa conteúdo)

Procedure Altera_Corr(var L:Tipo_Lista;var W:Tipo_Elemento;var X:Tipo_Elemento);

begin
L.Elemento [L.Cor].Conteudo := W.Conteudo + X.Conteudo;
end;

e.5 Inclusão no final (se for novo) - Alteração (se já existir-incrementa conteúdo)

Procedure Inclui_Alt(var L:Tipo_Lista;var X:Tipo_Elemento;var Cr:Integer);

begin
Acha_Val (L,X,W,CR);
if CR = 0
then Altera_Corr (L,W,X) {Procedure Altera_Corr}
else Inclui_Fim (L,X,CR); {Procedure Inclui_Fim }
end;

e.6 Inclusão Ordenada / Alteração - Inclui ordenadamente se não existir e altera conteúdo se
existir.

Procedure Inclui_AltOrd(var L:Tipo_Lista;var X:Tipo_Elemento;var CR:Integer);

begin
Acha_Val (L,X,W,CR);
if CR = 0
then Altera_Corr (L,W,X) {Procedure Altera_Corr}
else Inclui_Ord (L,X,CR); {Procedure Inclui_Ord }
end;

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 13 MANUEL

f. Exclusão

Exclui o elemento corrente e coloca em X o seu conteúdo.

Procedure Exclui_Corr (var L:Tipo_Lista;var X:Tipo_Elemento;var CR:Integer);

Var i : Integer;

Begin
if L.Cor = 0
then begin
CR := 2; {Não há corrente ou fim da Lista}
X.Chave := “”;
end
else begin
CR := 0;
X.Chave := L.Elemento [L.Cor].Chave;
X.Conteudo := L.Elemento [L.Cor].Conteudo;
if L.Cor = L.Fim
then L.Cor := 0 {Fica sem elemento corrente}
else begin
for i := L.Cor + 1 to L.Fim Do
begin
L.Elemento [i -1].Chave:=L.Elemento[ i ].Chave;
L.Elemento [i -1].Conteudo:=L.Elemento[ i ].Conteudo;
end;
end;
L.Fim := L.Fim - 1;
L.Num := L.Num - 1;
if L.Num = 0
then L.Ini := 0;
end;
end;

Exercício-2: Sejam LA e LB duas listas com os seguintes conteúdos:

LA = { a , b, c } e LB = {d , c , b }. Qual a saída produzida pelo trecho do algoritmo abaixo:

.............................
Prim_Corr(LA,XA,Cra);
While (Cra = 0) Do
Begin
Prim_Corr(LB,XB,Crb);
While (Crb = 0) Do
Begin
IF XA > XB
Then writeln(XB,XA)
Else writeln(XA,XB);
Prox_Corr(LB,XB,Crb);
end;
Prox_Corr(LA,XA,Cra);
end;
.............................

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 14 MANUEL

Exercício-3:

Construa um algoritmo para percorrer os elementos de uma Lista L, imprimindo apenas os

elementos que tiverem um conteúdo maior que o conteúdo do seu anterior.

ALG-EX03;

Var L : Tipo_Lista;
X,W : Tipo_Elemento;
CR: Integer;

Prim_Corr (L,X,Cr);
If Cr = 0 Then
Begin
W := X;
Prox_Corr (L,X,Cr);
While Cr = 0 Do
Begin
If X > W
Then writeln( X );
W := X;
Prox_Corr ( L,X,Cr );
end;

end; { Fim ALG-EX03 }

Exercício-4: Com o algoritmo do exercício anterior, indique a saída produzida para os casos
abaixo:

a) L = { } (Lista vazia)

b) L = { x }

c) L = { x , y }

d) L = { y , x }

e) L = { x , y , z , w , r , s , t }

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 15 MANUEL

Exercício-5: Considere o conjunto contendo dados consolidados mensais sobre o consumo
de produtos agrícolas em cada estado do país.

MÊS/REF UF PRODUTO NACIONAL IMPORTADO

02/91 RN MAÇA 90,00 190,00.

03/91 SP MAÇA 130,00 220,00
02/91 SP PERA 70,00 88,00
05/91 RN CAJU 89,00 234,00
................ ................ ................ ................ ................
08/91 PI ABACAXI 230,00 155,00
10/91 CE MANGA 49,00 130,00
11/91 PI ABACAXI 187,00 890,00
12/91 MA BANANA 245,00 345,00
09/91 SP MORANGO 678,00 980,00

Pergunta-se:

a. Qual o valor anual gasto em cada estado com cada produto?

b. Quais os estados que consomem mais produtos importados do que nacionais, e quais os
valores desses consumos?

*c. Quais os estados que consomem ‘Maçã’ ?

*d. Quais os estados que consome ‘Abacaxi’“ ou ‘Laranja’ ?

*e. Entre os produtos consumidos no PI, quais aqueles que tem um consumo nacional maior
do que o importado, e quanto valem esses consumos?

*f. Qual o valor gasto mensalmente em cada estado com cada produto ?

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 16 MANUEL

Solução:

a. Qual o valor anual gasto em cada estado com cada produto?

Program Agricola;
Const Dim =100;
type T_Dados = record
MesRef : String [ 5 ];
UF : String [ 2 ];
Produto : String [10] ;
Nacional : Real;
Importado : Real;
end;
T_Chave = record
UF : String [ 2 ];
Produto : String [ 10 ];
end;
T_Elemento = record
Chave : T_Chave;
Valor : Real;
end;
T_Lista = record
Ini : Integer;
Fim : Integer;
Cor : Integer;
Num : Integer;
Elemento : Array [1..Dim ] of T_Elemento;
end;
Var Lista : T_Lista; { Lista }
CR : Integer; { Código de retorno }
X : T_Elemento; { Elemento da Lista }
Arq : File of T_Dados; { Arquivo de Dados }
Dados : T_Dados; { Dados de entrada }
begin
CriaLista(Lista); {Associa o arquivo lógico Arq ao }
Assign(Arq, ‘Dados.txt’); { arquivo físico ‘Dados.txt ‘ }
Reset(Arq); { Posiciona no 1 registro do arquivo }
while (CR=0) and (not (eof (Arq))) do { Início do WHILE }
begin
Read (Arq,Dados); { Início da leitura dos dados}
with X.Chave do
begin
UF:=Dados.UF; {X.Chave.UF := Dados.UF}
Produto:=Dados.Produto; {X.Chave.Produto:=Dados.Produto}
end;
X.Valor:=Dados.Nacional+Dados.Importado;
{ Procedure que Inclui/Altera e Ordena os elementos da lista}
Inclui_AltOrd (Lista, X, Cr);
end; { Fim do WHILE }
Prim_Corr (Lista, X, CR);
While CR=0 do { Início do Loop de impressão }
begin
writeln (X.Chave.UF,X.Chave.Produto,X.Valor);
Prox_Corr (Lista,X,CR)
end; { Fim do Loop de impressão }
end.

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 17 MANUEL

b. Quais os estados que consomem mais produtos importados do que nacionais, e quais os
valores desse consumos?

Program Agrícola;
Const Dim =100;
type T_Dados = record
MesRef : String [ 5 ];
UF : String [ 2 ];
Produto : String [10] ;
Nacional : Real;
Importado : Real;
end;
T_Chave = record
UF : String [ 2 ];
end;
T_Elemento = record
Chave : T_Chave;
Nacional : Real;
Importado : Real;
end;
T_Lista = record
Ini : Integer;
Fim : Integer;
Cor : Integer;
Num : Integer;
Elemento : Array [1..Dim ] of T_Elemento;
end;
Var Lista : T_lista; { Lista }
CR : Integer; { Código de retorno }
X : T_Elemento; { Elemento da Lista }
Arq : File of T_Dados; { Arquivo de Dados }
Dados : T_Dados; { Dados de entrada }

begin
CriaLista(Lista);
Assign(Arq, ‘Dados.txt ‘);
Reset (Arq);
while ( CR=0 ) and (not (eof (arq) ) ) do { Início do WHILE }
begin
Read (Arq, Dados); { Início da leitura dos dados}
X.Chave.UF:=Dados.UF;
X.Nacional:=Dados.Nacional;
X.Importado:=Dados.Importado;
{Procedure que Inclui/Altera e Ordena os elementos da lista}
Inclui_AltOrd (Lista, X, CR);
end; { Fim do WHILE }
Prim_Corr (Lista, X, CR) ;
while CR=0 do
begin
if X.Importado > X.Nacional
then writeln (X.Chave.UF,X.Importado,X.Nacional);
Prox_Corr (Lista, X, CR)
end;
end.

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 18 MANUEL

*c. Quais os Estados que consomem ‘Maça ‘?

Program Agrícola;
Const Dim =100;
type T_Dados = record
MesRef : String [ 5 ];
UF : String [ 2 ];
Produto : String [10] ;
Nacional : Real;
Importado : Real;
end;
T_Chave = record
UF : String [ 2 ];
Produto : String [10 ];
end;
T_Elemento = record
Chave : T_Chave;
end;
T_Lista = record
Ini : Integer;
Fim : Integer;
Cor : Integer;
Num : Integer;
Elemento : Array [1..Dim ] of T_Elemento;
end;
Var Lista : T_lista; { Lista }
CR : Integer; { Código de retorno }
X : T_Elemento; { Elemento da Lista }
Arq : File of T_Dados; { Arquivo de Dados }
Dados : T_Dados; { Dados de entrada }

begin
CriaLista(Lista);
Assign(Arq, ‘Dados.txt ‘);
Reset(Arq);
while (CR=0) and (not(eof(arq) ) ) do
begin
Read(Arq,Dados); { Início da leitura dos dados }
with X.Chave do
begin
UF := Dados.UF;
Produto := Dados.Produto;
end;
{ Procedure que Inclui e Ordena os elementos da lista }
Inclui_Ord (Lista,X,CR );
end;
Prim_Corr(Lista, X, CR );
while CR=0 do
begin
if X.Chave.Produto=‘Maçã ‘
then writeln (X.Chave.UF);
Prox_Corr (Lista, X, CR);
end;

end.

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 19 MANUEL

*d. Quais os estados que consomem ‘Abacaxi ‘ ou ‘Laranja ‘?

Program Agrícola;
Const Dim =100;
type T_Dados = record
MesRef : String [ 5 ];
UF : String [ 2 ];
Produto : String [10] ;
Nacional : Real;
Importado : Real;
end;
T_Chave = record
UF : String [ 2 ];
Produto : String [10];
end;
T_Elemento = record
Chave : T_Chave;
end;
T_Lista = record
Ini : Integer;
Fim : Integer;
Cor : Integer;
Num : Integer;
Elemento : Array [1..Dim ] of T_Elemento;
end;
Var Lista : T_lista; { Lista }
CR : Integer; { Código de retorno }
X : T_Elemento; { Elemento da Lista }
Arq : File of T_Dados; { Arquivo de Dados }
Dados : T_Dados; { Dados de entrada }
begin
CriaLista(Lista);
Assign (Arq, ‘Dados.txt ‘);
Reset (Arq);
While (CR=0) and (not(eof(Arq) ) ) do
begin
Read(Arq,Dados); { Início da leitura dos dados}
X.Chave.UF:=Dados.UF;
X.Chave.Produto:=Dados.Produto;
{Procedure que Inclui e Ordena os elementos da lista}
Inclui_Ord(Lista, X, CR);
end;
Prim_Corr (Lista, X, CR);
while CR=0 do
begin
if X.Chave.Produto= ‘Abacaxi ‘ or X.Chave.Produto=’Laranja ‘
then writeln (X.Chave.UF);
Prox_Corr (Lista, X, CR);
end;
end.

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 20 MANUEL

*e. Entre os produtos consumidos no PI, quais aqueles que tem um consumo nacional maior do
que o importado, e quanto valem esses consumos.

Program Agrícola;
Const Dim =100;
type T_Dados = record
MesRef : String [ 5 ];
UF : String [ 2 ];
Produto : String [10] ;
Nacional : Real;
Importado : Real;
end;
T_Chave = record
Produto : String [10];
end;
T_Elemento = record
Chave : T_Chave;
Nacional : Real;
Importado : Real;
end;
T_Lista = record
Ini : Integer;
Fim : Integer;
Co : Integer;
Num : Integer;
Elemento : Array [1..Dim ] of T_Elemento;
end;
Var Lista : T_lista; { Lista }
CR : Integer; { Código de retorno }
X : T_Elemento; { Elemento da Lista }
Arq : File of T_Dados; { Arquivo de Dados }
Dados : T_Dados; { Dados de entrada }

begin
CriaLista(Lista);
Assign (Arq, ‘Dados.txt ‘);
Reset(Arq);
while (CR=0) and (not(eof(Arq) ) ) do
begin
Read(Arq,Dados); { Início da leitura dos dados }
X.Chave.Produto:=Dados.Produto;
X.Nacional:=Dados.Nacional
X.Importado:=Dados.Importado;
{ Procedure que Inclui/Altera e Ordena os elementos da lista }
if Dados.UF= ‘PI ‘ then Inclui_AltOrd(Lista, X, CR);
end:
Prim_Corr (Lista, X, CR);
while CR=0 do
begin
if X.Nacional > X.Importado
then writeln (X.Chave.Produto,X.Nacional,X.Importado);
Prox_Corr(Lista,X,CR);
end;
end.

ESTRUTURA DA INFORMAÇÃO- MÓDULO-01 21 MANUEL