Estr Módulo 01 Slides PDF

UNICARIOCA
ESTRUTURA DE
DADOS
MÓDULO-01
LISTAS
LISTAS LINEARES
MOTIVAÇÃO
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.
ESTRUTURA DE DADOS
MÓDULO_01 - LISTAS 1 MANUEL
LISTAS LINEARES
DEF: LISTA é uma coleção ordenada de componentes do
mesmo tipo. Tipicamente este é o tipo registro (record);
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.
LISTAS LINEARES
REPRESENTAÇÃO FÍSICA
L = {x1,x2,x3,.......,xn} ⇒ Lista com n nós.
INÍCIO → CRIAÇÃO DA LISTA
X1 X2 X3 ...... Xn
INFO ELO INFO ELO INFO ELO INFO ELO
INFO ⇒ INFORMAÇÃO / ELO ⇒ ENDEREÇO DO PRÓXIMO NÓ
ESTRUTURA DE DADOS
LISTAS LINEARES
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.
LISTAS LINEARES
FORMAS DE REPRESENTAÇÃO
POR CONTIGÜIDADE ⇒ LISTA SEQÜENCIAL
POR ENCADEAMENTO ⇒ LISTA LIGADA
ESTRUTURA DE DADOS
LISTAS LINEARES
POR CONTIGÜIDADE
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.
LISTAS LINEARES
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).
ESTRUTURA DE DADOS
LISTAS LINEARES
VANTAGEM
PODE-SE FACILMENTE ALTERAR OU DETERMINAR O

VALOR DE UM DADO. X[1] := 11;
DESVANTAGENS
É PRECISO ESPECIFICAR ANTECIPADAMENTE A

DIMENSÃO MÁXIMA DO VETOR ONDE A LISTA VAI SER
IMPLEMENTADA. Var Reg: array [1..1000] of record;
INSERÇÕES E REMOÇÕES PODEM EXIGIR
CONSIDERÁVEL MOVIMENTAÇÃO DE DADOS.
LISTAS LINEARES
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?
Lista 1 2 3 4 5 6 ...... 797 798 799 800
REGISTRO (nó) NOME CPF
ESTRUTURA DE DADOS
LISTAS LINEARES
antes 1 2 3 4 5 797 798 799 800
depois 1 2 3 5 6 798 799 800 801
O NÓ 4 RECEBE O NOVO NOME E O NOVO CPF
REGISTRO (nó) NOME CPF
LISTAS LINEARES
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 1 2 3 4 (4) 4 4
for I := 800 Downto 4 do Reg[801] := Reg[800];
Reg[I+1] := Reg [I]; Reg[5] := Reg[4];
Reg [4].Nome := “Novo Nome”;
Reg [4].CPF := “Novo CPF”;
N_Lista := 801;
end.
ESTRUTURA DE DADOS
LISTAS LINEARES
for I := 4 to 800 do
Reg[I+1] := Reg [I];
end. 1 2 3 4 (4) 4 4
Reg[5] = Reg[4];
Reg[6] = Reg[5] = Reg[4];
Reg[7] = Reg[6] = Reg[4]; NÃO FUNCIONA !
Reg[8] = Reg[7] = Reg[4];

....................................................
Reg[800] = Reg[799]; = Reg[4];
Reg[801] = Reg[800]; = Reg[4];
MÓDULO-03
DEFINIÇÕES PARA IMPLEMENTAÇÃO (PASCAL)
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 ⇒ FIM DA LISTA (POSIÇÃO DO ÚLTIMO NÓ)
COR=00 ⇒ NÓ CORRENTE (INDEXADOR)
NUM=03 ⇒ NÚMERO DE ELEMENTOS DA LISTA (NÓS)
ESTRUTURA DE DADOS
DEFINIÇÕES PARA IMPLEMENTAÇÃO (PASCAL)
x1 x2 x3 ............
01 02 03 DIM
INI FIM COR NUM x1 x2 x3

LISTA ⇒
DESCRITORES ELEMENTOS - NÓS
DIM
LISTA (L) = DESCRITORES + NÓS (INFORMAÇÕES)

DESCRITORES ⇒ definem as características da Lista: Início, Fim,
Número de Elementos, 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.
INI FIM COR NUM x1 x2 x3

LISTA ⇒
DESCRITORES ELEMENTOS - NÓS
DIM
LISTA (L) = DESCRITORES + NÓS (INFORMAÇÕES)
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 DE DADOS
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;
end;
Var { Declaração das Variáveis }
L : Tipo_Lista;{ L = Lista}
X,W : Tipo_Elemento; {Elemento da Lista-Informações}
Cr : Integer; {Código de retorno}
POR ENCADEAMENTO
CARACTERÍSTICA ⇒
Cada elemento é associado a outro através de um
PONTEIRO ⇒ elo de ligação.
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.
ESTRUTURA DE DADOS
POR ENCADEAMENTO
X1 X2 X3 ...... Xn
FIM
INFO ⇒ INFORMAÇÃO / ELO ⇒ ENDEREÇO DO PRÓXIMO NÓ
SEQUENCIALIDADE ⇒ é preservada de uma forma LÓGICA
e não de uma forma FÍSICA.
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 sequências corresponderá a uma ordenação
diferente.
POR ENCADEAMENTO
X3 2 X4 0 X1 4 X2 1
01 02 03 04
SEQÜENCIALIDADE LÓGICA - (NÃO FÍSICA)
DESCRITORES
INI = 03 ⇒ APONTA PARA O PRIMEIRO
FIM = 02 ⇒ APONTA PARA O ÚLTIMO
COR= 03 ⇒ APONTA PARA O CORRENTE
NUM= 04 ⇒ NÚMERO DE ELEMENTOS
ESTRUTURA DE DADOS
POR ENCADEAMENTO
X3 2 X4 0 X1 4 X2 1
01 02 03 04
SEQUENCIALIDADE 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 Listas Encadeadas. Para as linguagens que não
oferecem este tipo de recurso, usa-se o Encadeamento
Simulado que será visto a seguir.
ENCADEAMENTO SIMULADO
INFO ⇒ X3 X4 X1 X2
ELO ⇒ 02 00 05 00 01
01 02 03 04 05
FIM DA LISTA PRÓXIMO
LIVRE
DESCRITORES ⇒ STATUS DA LISTA
INI = 03 ⇒ APONTA PARA O PRIMEIRO
FIM = 02 ⇒ APONTA PARA O ÚLTIMO
LIV = 04 ⇒ APONTA PARA O PRÓXIMO LIVRE
NUM= 04 ⇒ NÚMERO ATUAL DE ELEMENTOS
ESTRUTURA DE DADOS
Penso, logo existo.
Daria tudo que sei, pela metade do

que ignoro.
A leitura de todos os bons livros é

como uma conversação com as
pessoas mais qualificadas dos
séculos passados.
Não há nada que dominemos

inteiramente a não ser os nossos
pensamentos.
Não existem métodos fáceis para

resolver problemas difíceis.
RENÉ DESCARTES
(La Haye en Touraine-1596/Estocolmo-1650
ESTRUTURA DE DADOS
OPERAÇÕES BÁSICAS - ALOCAÇÃO CONTÍGUA
CRIAÇÃO DA LISTA ⇒ Cria uma Lista vazia.
PROCEDURE CRIA_LISTA (var L : Tipo_Lista);
VERIFICAÇÃO ⇒ Testa se lista está vazia

Retorna (TRUE) se Lista Vazia.
FUNCTION LISTA_VAZIA (L:Tipo_Lista) : Boolean;
VERIFICAÇÃO ⇒ Testa se lista está cheia

Retorna (TRUE) se Lista cheia.
FUNCTION LISTA_CHEIA (L:Tipo_Lista) : Boolean;

ACESSO SEQUENCIAL ⇒ 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);
ACESSO SEQUENCIAL ⇒ Posiciona no próximo

elemento da Lista e retorna seu conteúdo em X.
PROCEDURE PROX_CORR (var L:Tipo_Lista;var X:
Tipo_Elemento;var CR:integer);
ESTRUTURA DE DADOS
ACESSO POR VALOR ⇒ 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);

INCLUSÃO/ALTERAÇÃO
⇒ Inclui elemento X no final da Lista
PROCEDURE INCLUI_FIM (varL:Tipo_Lista; var
X:Tipo_Elemento; var CR:Integer);
⇒ Inclui elemento X no elemento corrente da Lista
PROCEDURE INCLUI_CORR (var L:Tipo_Lista;
var X:Tipo_Elemento; var CR:Integer);
ESTRUTURA DE DADOS
⇒ Inclui elemento X ordenadamente na Lista sem
permitir duplicatas. Pesquisa para saber onde incluir.
PROCEDURE INCLUI_ORD (varL:Tipo_Lista; var
X:Tipo_Elemento;var CR:Integer);
⇒ Altera os campos do elemento corrente
(Incrementa conteúdo).
PROCEDURE ALTERA_CORR (var L:Tipo_Lista;var
W:Tipo_Elemento;var X:Tipo_Elemento);

⇒ 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);
⇒ 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);
ESTRUTURA DE DADOS
EXCLUSÃO ⇒ Exclui o elemento corrente e coloca o
seu conteúdo em X.
PROCEDURE EXCLUI_CORR (var L:Tipo_Lista;
var X:Tipo_Elemento; var CR:Integer);
VAMOS UTILIZAR INICIALMENTE APENAS

DUAS ROTINAS DE ACESSO SEQUÊNCIAL
PROCEDURE PRIM_CORR (var L:Tipo_Lista; var X:
Tipo_Elemento; var CR:Integer);
ACESSO SEQUENCIAL ⇒ Posiciona no 1º elemento
da Lista e retorna seu conteúdo em X.
PROCEDURE PROX_CORR (var L:Tipo_Lista;var X:

Tipo_Elemento;var CR:integer);
ACESSO SEQUENCIAL ⇒ Posiciona no próximo
elemento da Lista e retorna seu conteúdo em X.
ESTRUTURA DE DADOS
Exercício-2: Sejam LA e LB duas listas com os seguintes
conteúdos: LA = { a, b, c } e LB = {d, c, b }. (PAG. 14)
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;

LA = { a, b, c } e LB = { d, c, b }
INSTÂNCIA Cra/Crb SAÍDA
Prim_Corr(LA,XA,Cra); XA=a XB=d 0/0 a,d
While (Cra = 0) Do XA=a XB=c 0/0 a,c
Begin
XA=a XB=b 0/0 a,b
Prim_Corr(LB,XB,Crb);
While (Crb = 0) Do XA=a XB=? 0/1
Begin XA=b XB=d 0/0 b,d
IF XA > XB XA=b XB=c 0/0 b,c
Then writeln(XB,XA)
XA=b XB=b 0/0 b,b
Else writeln(XA,XB);
Prox_Corr(LB,XB,Crb); XA=b XB=? 0/1
end; XA=c XB=d 0/0 c,d
Prox_Corr(LA,XA,Cra); XA=c XB=c 0/0 c,c
end;
XA=c XB=b 0/0 b,c
XA=? XB=? 1/1
ESTRUTURA DE DADOS
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. (PAG.15)
4 6 1 8 3 2 7 10
x x x x
MARIA JOÃO PEDRO BETH ANTÔNIO LEDA LUIS SUSI

x x x x
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 }
ESTRUTURA DE DADOS
L= { 1, 4, 6, 2, 10 }
ALG-EX03;
Var L : Tipo_Lista; INSTÂNCIA CR SAÍDA
X,W : Tipo_Elemento; X=1 W=1 0 W=X -
CR : Integer; X=4 W=1 0 LÊ X -
Prim_Corr (L,X,CR); X=4 W=1 0 TESTA 4
If CR = 0 Then X=4 W=4 0 W=X -
Begin X=6 W=4 0 LÊ X -
W := X;
X=6 W=4 0 TESTA 6
Prox_Corr (L,X,CR);
While CR = 0 Do X=6 W=6 0 W=X -
If X > W X=2 W=6 0 TESTA -
Then writeln( X ); X=2 W=2 0 W=X -
W := X; X=10 W=2 0 LÊ X -
Prox_Corr ( L,X,CR );
X=10 W=2 0 TESTA 10
end;
X=10 W=10 0 W=X -
end; { Fim ALG-EX03 }
X=? W=10 1 FIM -
L= { 1, 0, 4, 4, 6 }
ALG-EX03;
Var L : Tipo_Lista; INSTÂNCIA CR SAÍDA
X,W : Tipo_Elemento; X=1 W=1 0 W=X -
CR : Integer; X=0 W=1 0 LÊ X -
Prim_Corr (L,X,CR); X=0 W=1 0 TESTA -
If CR = 0 Then X=0 W=0 0 W=X -
W := X;
X=4 W=0 0 TESTA 4
Prox_Corr (L,X,CR);
While CR = 0 Do X=4 W=4 0 W=X -
If X > W X=4 W=4 0 TESTA -
Then writeln( X ); X=4 W=4 0 W=X -
W := X; X=6 W=4 0 LÊ X -
Prox_Corr ( L,X,CR );
X=6 W=4 0 TESTA 6
end;
end; { Fim ALG-EX03 } X=6 W=6 0 W=X -
X=? W=6 1 FIM -
ESTRUTURA DE DADOS
Exercício-5: Considere o conjunto contendo dados
consolidados mensais sobre o consumo de produtos agrícolas
em cada estado do país. (PAG.16)
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
Exercício-5: Considere o conjunto contendo dados

consolidados mensais sobre o consumo de produtos agrícolas
em cada estado do país.
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 DE DADOS
a. Qual o valor anual gasto em cada estado com cada produto?
RELATÓRIO
UF PRODUTO VALOR ANUAL
AC BANANA 200,00
AC LARANJA 300,00
BA LARANJA 150,00
BA MAÇA 200,00
CE MAMÃO 200,00
CE MORANGO 800,00
..........................................................................
..........................................................................
MA ABACAXI 300,00
PI LARANJA 100,00
RJ BANANA 200,00
RJ MORANGO 600,00
SP BANANA 200,00
SP MAMÃO 100,00
SP PÊRA 900,00
Program Agricola; {DEFINIÇÃO DOS TIPOS}

Const Dim =100;
type T_Dados = record {LAYOUT DE ENTRADA}
MesRef : String [5];
UF : String [2];
Produto : String [10] ;
Nacional : Real;
Importado: Real;
end;
T_Chave = record {DEFINIÇÃO DA CHAVE !}
UF : String [2];
Produto: String [10];
end;
T_Elemento = record TIPO ELEMENTO
Chave: T_Chave; CHAVE VALOR
Valor : Real;
end; UF PRODUTO VALOR
T_Lista = record {DEFINIÇÃO DA LISTA = DESCRITORES+NÓS}
Ini : Integer; {DESCRITORES}
Fim : Integer;
Cor : Integer;
Num : Integer;
Elemento : Array [1..Dim ] of T_Elemento;
end;
ESTRUTURA DE DADOS
DIAGRAMA FÍSICO
REGRA DE
NEGÓCIO
LISTA MONTADA
LEITURA EM MEMÓRIA
GERAÇAO
DA LISTA
RELATÓRIO
UF PRODUTO VALOR
BASE DE DADOS AC UVA 80,00
ARQUIVO DE ENTRADA ......................................
“C:/DADOS/........./” SP PÊRA 100,00
{DEFINIÇÃO DAS VARIÁVEIS}
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 }
BASE DE DADOS
ARQUIVO DE ENTRADA
ARQ:FILE OF T_DADOS
ESTRUTURA DE DADOS
{MONTAGEM DA LISTA - REGRA DE NEGÓCIO}
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 }
end;
{IMPRESSÃO DO RELATÓRIO}
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. { Fim do PROGRAMA}
ESTRUTURA DE DADOS
do que nacionais, e quais os valores desse consumos?
LISTA EM MEMÓRIA
UF NACIONAL (R$) IMPORTADO (R$)
AC 400,00 720,00
AM 200,00 600,00
AP 400,00 540,00
BA 700,00 420,00
CE 600,00 300,00
..........................................................................
..........................................................................
MG 300,00 900,00
PB 100,00 500,00
PE 700,00 800,00
RJ 820,00 400,00
SC 800,00 910,00
SP 980,00 600,00

RELATÓRIO
UF NACIONAL (R$) IMPORTADO (R$)
AC 400,00 720,00
AM 200,00 600,00
AP 400,00 540,00
..........................................................................
..........................................................................
MG 300,00 900,00
PB 100,00 500,00
PE 700,00 800,00
SC 800,00 910,00
ESTRUTURA DE DADOS
MUDANÇA NA REGRA DE NEGÓCIO = LÓGICA !
⇒ FAZER O TESTE A PRIORI !
⇒ SÓ INCLUIR NA LISTA SE X.IMPORTADO>X.NACIONAL
EXEMPLO REGISTRO LIDO NA BASE DE DADOS (MG)
X.CHAVE.UF = MG
X.NACIONAL = 200,00
X.IMPORTADO = 100,00
UF NACIONAL IMPORTADO VALORES DA UF = MG
NA LISTA QUE ESTÁ EM
MG 300,00 900,00 MEMÓRIA !
FAZER O TESTE A PRIORI ⇒ ERRO DE LÓGICA !
REGRA DE NEGÓCIO = LÓGICA = ALGORITMOS !
FLUTUA ACIMA DO BEM E DO MAL !
ELEMENTOS LISTA
MG 100 200
AC 200 100
RJ 300 400
SP 400 600
CE 100 400
BA 200 300
RJ 100 200
MG 200 300
SC 100 200
SP 200 300
ESTRUTURA DE DADOS
ELEMENTOS LISTA
MG 100 200 AC 200 100

AC 200 100 BA 200 300
RJ 300 400 CE 100 400
SP 400 600
CE 100 400
MG 200 300 MG 100 200
BA 200 300
RJ 100 200 RJ 300 400
RJ 100 200
SC 100 200
MG 200 300
SP 200 300 SP 400 600
SC 100 200
SP 200 300
ESTRUTURA DE DADOS

Estr Módulo 01 Slides PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Estr Módulo 01 Slides PDF

Enviado por

Direitos autorais:

Formatos disponíveis

UNICARIOCA

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.

DEF FORMAL: LISTA é um conjunto de n nós x1, x2, ........., xn

INÍCIO → CRIAÇÃO DA LISTA

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

1- Acessar o k-ésimo nó da lista para obter e/ou

POR CONTIGÜIDADE ⇒ LISTA SEQÜENCIAL

POR ENCADEAMENTO ⇒ LISTA LIGADA

A maneira mais singela (simples) e obvia de

PODE-SE FACILMENTE ALTERAR OU DETERMINAR O

É PRECISO ESPECIFICAR ANTECIPADAMENTE A

Exemplo-2: Suponhamos uma lista com NOME e CPF

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

REGISTRO (nó) NOME CPF

antes 1 2 3 4 5 797 798 799 800

depois 1 2 3 5 6 798 799 800 801

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

REGISTRO (nó) NOME CPF

Reg[6] = Reg[5] = Reg[4];

Reg[7] = Reg[6] = Reg[4]; NÃO FUNCIONA !

Reg[8] = Reg[7] = Reg[4];

DESCRITORES DA LISTA (DEFINEM O ESTADO DA LISTA)

INI FIM COR NUM x1 x2 x3

LISTA (L) = DESCRITORES + NÓS (INFORMAÇÕES)

INI FIM COR NUM x1 x2 x3

LISTA (L) = DESCRITORES + NÓS (INFORMAÇÕES)

ELEMENTO (Nó) ⇒ CHAVE CONTEÚDO

CHAVE ⇒ é uma informação normalmente utilizada para

CONTEÚDO ⇒ são as informações (dados) que se deseja

INÍCIO → CRIAÇÃO DA LISTA

INI = 03 ⇒ APONTA PARA O PRIMEIRO

FIM = 02 ⇒ APONTA PARA O ÚLTIMO

COR= 03 ⇒ APONTA PARA O CORRENTE

NUM= 04 ⇒ NÚMERO DE ELEMENTOS

INI = 03 ⇒ APONTA PARA O PRIMEIRO

FIM = 02 ⇒ APONTA PARA O ÚLTIMO

LIV = 04 ⇒ APONTA PARA O PRÓXIMO LIVRE

NUM= 04 ⇒ NÚMERO ATUAL DE ELEMENTOS

Daria tudo que sei, pela metade do

A leitura de todos os bons livros é

Não há nada que dominemos

Não existem métodos fáceis para

VERIFICAÇÃO ⇒ Testa se lista está vazia

VERIFICAÇÃO ⇒ Testa se lista está cheia

OPERAÇÕES BÁSICAS - ALOCAÇÃO CONTÍGUA

ACESSO SEQUENCIAL ⇒ Posiciona no próximo

ACESSO POR VALOR ⇒ Procura o elemento com

PROCEDURE ACHA_VAL (var L:Tipo_Lista;var

OPERAÇÕES BÁSICAS - ALOCAÇÃO CONTÍGUA

OPERAÇÕES BÁSICAS - ALOCAÇÃO CONTÍGUA

EXCLUSÃO ⇒ Exclui o elemento corrente e coloca o

PROCEDURE EXCLUI_CORR (var L:Tipo_Lista;

var X:Tipo_Elemento; var CR:Integer);

VAMOS UTILIZAR INICIALMENTE APENAS

PROCEDURE PROX_CORR (var L:Tipo_Lista;var X:

OPERAÇÕES BÁSICAS - ALOCAÇÃO CONTÍGUA

MARIA JOÃO PEDRO BETH ANTÔNIO LEDA LUIS SUSI

MÊS/REF UF PRODUTO NACIONAL IMPORTADO

Exercício-5: Considere o conjunto contendo dados