O documento discute estruturas de dados dinâmicas como listas, pilhas, filas e árvores binárias em Pascal. Explica como declarar e manipular cada estrutura através de operações como inserção, remoção e busca de elementos. Também aborda ponteiros, recursividade e como representar cada estrutura de dados na memória usando registros e ponteiros.

1. Aula 003
Estrutura de Dados
PRONATEC
Programa Nacional de Acesso ao
Ensino Técnico e Emprego

2. PRONATEC
Programa Nacional de Acesso
ao Ensino Técnico e Emprego

3. 1. Uma pausa: Ponteiro no Delphi
• Para algumas estruturas dinâmicas em Pascal
precisamos usar o recurso de “Ponteiro”
• Um Ponteiro é na verdade o endereço de memória
RAM de um dado: variável ou estrutura
• Para declararmos um ponteiro em Pascal usamos o
símbolo “^” na sua declaração em frente do tipo que
ele representa. Ex: var p : ^integer; declara “p” como
um ponteiro para “inteiro”.
• Significa que “p” aponta para um dado do tipo
“inteiro” diretamente na memória RAM
• Para acessarmos o conteúdo de “p” usamos, no
código, o símbolo “^” após o ponteiro: “p^” é o
inteiro apontado por “p”. Ex: “p^ := 1;” – “p” agora
aponta para o inteiro “1” na memória RAM.

4. 2. Estrutura: Lista
• Também chamada de “Lista Ligada” ou “Lista
Encadeada”, é uma estrutura em que cada
elemento contém um dado e um ponteiro que
aponta para o próximo elemento da lista.
• O 1º elemento é a cabeça (head) da lista, o
restante a cauda (tail). No último elemento o
ponteiro para o próximo não aponta para nada.
Em Pascal indicamos por “nil” que significa um
“Ponteiro Vazio” que não aponta para nada.

5. 3. Definição e Operação com Lista
• Para definir uma lista de inteiros em pascal:
Type
ApontaElemento : ^Elemento;
Elemento : record
num: integer;
prox: ApontaElemento;
end;
Lista : ApontaElemento; // Tipo Lista: Aponta a cabeça (1º Elemento)
• Operações com uma lista:
• CriaLista(): Cria um ponteiro para uma nova lista
• Cardinalidade(p): Retorna quantos elementos tem P
• InsereItem(x,p): Inclui item “x” na lista “p”
• RemoveItem(x,p): Exclui 1ª ocorrência de x em p
• RemovePrimeiro(p): Excluir cabeça da lista “p”
• Busca(x,p): Retorna ponteiro para “x” na lista “p” ou
“nil” se não localizado

6. 4. Operações com Listas
• Cria uma lista vazia:
Function CriaLista () : Lista;
Begin
result := nil;
End;
• Verificar o tamanho da lista P
Function Cardinalidade (p:Lista):integer;
Var i:integer;
Begin
i:=0;
while p<>nil do begin p := p^.prox; inc(i); end;
result := i;
End;
• Busca um elemento na Lista “p”
Function Busca(x:integer; p:Lista):ApontaElemento;
Var q:ApontaElemento;
Begin
q := p;
while (q<>nil) and (q^.num<>x) do q:=q^.prox;
result := q;
End;
• Inserir um elemento na Lista
Procedure Insere (x:integer; var p:Lista);
Var q:ApontaElemento;
Begin
new(q); // Abre um espaço na RAM
q^.num := x; q^.prox := p; p := q;
End;
• Remover 1º elemento de uma Lista
Procedure RemovePrimeiro(var p:Lista);
Var q:ApontaElemento;
Begin
if p=nil then exit;
q := p^.prox; dispose(p); p : = q;
End;

7. 5. Remoção Específica em Lista
• Remover 1ª ocorrência do elemento “x” na Lista
Function Remove(x:integer; var p:Lista):boolean;
Var q,r:ApontaElemento;
Begin
result := false; if p=nil then exit; // Lista vazia – sai
result := True;
if p^.num=x then begin // 1º da Lista – Remove o Primeiro
RemovePrimeiro(p); exit;
end;
q := p;
repeat
r := q; q := q^.prox;
until (q = nil) or (q^.num = x);
if q <> nil then begin // Se Encontrou x Remove
r^.prox := q^.prox; dispose(q);
end;
End;

8. 6. Estrutura: Pilha
• Uma pilha é uma lista especial em que os
elementos são inseridos sempre na cabeça e
retirados sempre dela. Assim a impressão que se
tem é que estamos “empilhando” os dados e
quando retiramos um dado estamos
“desempilhando”
• As pilhas são conhecidas em
estrutura de dados como
uma fila FILO (First In – Last
Out): primeiro a entrar,
último a sair.

9. 7. Definição e Operação da Pilha
• Para definir uma Pilha de inteiros em pascal:
Type
ApontaElemento : ^Elemento;
Elemento : record
num: integer;
prox: ApontaElemento;
end;
Pilha : ApontaElemento; // Tipo Pilha: Aponta sempre o Topo
• Operações com uma lista:
• CriaPilha(): Cria um ponteiro para uma nova pilha
• Cardinalidade(p): Número de itens na pilha
• Empilha(x,p): Inclui item “x” no topo da pilha “p”
• Desempilha(p): Retorna elemento do topo e
diminui o tamanho da pilha em uma unidade

10. 8. Operações com Pilhas
• Cria uma nova Pilha:
Function CriaPilha() : Pilha;
Begin
result := nil;
End;
• Verificar o tamanho da pilha P
Function Cardinalidade (p:Pilha):integer;
Var i:integer;
Begin
i:=0;
while p<>nil do begin
p := p^.prox; inc(i);
end;
result := i;
End;
• Empilha um elemento na pilha
Procedure Empilha (x:integer; var p:Pilha);
Var q:ApontaElemento;
Begin
new(q); // Abre um espaço na RAM
q^.num := x; q^.prox := p; p := q;
End;
• Desempilha elemento da pilha P
Function Desempilha(var p:Pilha; var x:integer):boolean;
Var q:ApontaElemento;
Begin
result := false; if p=nil then exit; result := true;
x := p^.num; q := p^.prox; dispose(p); p : = q;
End;

11. 9. Estrutura: Fila
• Uma fila é uma lista especial em que os
elementos são inseridos sempre como último da
cauda e retirado sempre o primeiro da cabeça.
Assim a impressão que se tem é que estamos
“enfileirando” os dados.
• As filas por definição são FIFO (First In – First
Out): primeiro a entrar é o primeiro a sair.

12. 10. Definição e Operação na Fila
• Para definir uma Fila de inteiros em pascal:
Type
ApontaElemento : ^Elemento;
Elemento : record
num: integer;
prox: ApontaElemento;
end;
Fila : ApontaElemento; // Tipo Fila: Aponta o último elemento incluído
• Operações com uma Fila:
• CriaFila(): Cria um ponteiro para uma nova fila
• Cardinalidade(p): Número de itens na fila
• Enfileira(x,p): Inclui item “x” na fila “p”
• Retira(p): Remove o elemento mais “antigo” na
lista “p”, que é o mais antigo na fila

13. 11. Operações com Filas
• Cria uma nova Fila:
Function CriaFila() : Fila;
Begin
result := nil;
End;
• Verificar o tamanho da fila P
Function Cardinalidade (p:Fila):integer;
Var i:integer;
Begin
i:=0;
while p<>nil do begin
p := p^.prox; inc(i);
end;
result := i;
End;
• Empilha um elemento na fila
Procedure Enfileira (x:integer; var p:Fila);
Var q:ApontaElemento;
Begin
new(q); // Abre um espaço na RAM
q^.num := x; q^.prox := p; p := q;
End;
• Retirar elemento da Fila (o mais antigo)
Function Retira(x:integer; var p:Fila):boolean;
Var q,r:ApontaElemento;
Begin
result := false; if p=nil then exit; result := True;
if p^.prox=nil then begin // Fila de 1 elemento
x := p^.num; p := nil; exit;
end;
q := p;
repeat r:=q; q:= q^.prox; until (q^.prox = nil);
x := q^.num; r^.prox := nil; dispose(q);
End;

14. 12. Recursividade
• É o processo que para resolver um problema chama
ele mesmo novamente. Ou seja, uma função que
chama ela mesma no seu funcionamento. Exemplo:
Function Fatorial (n:integer):integer;
Begin
if n=0 then result:=1
else result := n * Fatorial (n-1);
End;
• Alguns problemas computacionais só podem ser
resolvidos pela recursão. Quando for possível
devemos evitar a recursividade pois consome mais
recursos e costuma ficar mais lento e ineficiente que
as formas normais de repetição: for, while, repeat

15. 13. Estrutura: Árvore Binária
• Uma árvore binária é uma estrutura onde cada
elemento aponta dois outros, um a sua esquerda
e outro a sua direita. Na medida em que se inclui
novos elementos dá-se a impressão de que a
árvore “cresce” para baixo.
• Cada elemento
na árvore
também é
chamado de
“Nó”

16. 14. Definição e Operação em Árvore
• Para definir uma Árvore de inteiros em pascal:
Type
ApontaElemento : ^Elemento;
Elemento : record
num: integer;
esq, dir: ApontaElemento;
end;
Arvore: ApontaElemento; // Tipo Árvore: Aponta o elemento topo (raiz) da estrutura
• Operações com uma Árvore:
• CriaArvore(): cria ponteiro para uma nova árvore
• InsereEsq(x,a): insere “x” à esquerda
• InsereDir(x,a): insere “x” à direita
• Percorre(a): Percorre todos elementos da árvore