UNIVERSIDADE POLITÉCNICA

APOLITECNICA
Escola Superior de Gestão, Ciências e Tecnologias
Docente: Mestre Simão Chinama

Algorimos e Estrutura de Dados

Ano lectivo 2024
 Capitulo I
Introdução
Conceito de Dado
Definimos dado como uma sequência de símbolos quantificados ou
quantificáveis. Portanto, um texto é um dado.

Também são dados imagens, sons e animação, pois todos podem ser
quantificados a ponto de alguém que entra em contato com eles ter
eventualmente dificuldade de distinguir a sua reprodução, a partir da
representação quantificada, com o original.

Os dados podem ser totalmente descritos através de

representações formais, estruturais. Dentro de um computador,
trechos de um texto podem ser ligados virtualmente a outros trechos,
por meio de contiguidade física ou por "ponteiros", isto é, endereços
da unidade de armazenamento sendo utilizada. Ponteiros podem fazer a
ligação de um ponto de um texto a uma representação quantificada de
uma figura, de um som, etc.
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
1. Lista
Uma lista, como array, pode conter uma sequência ordenada
de registos (records) com elementos disponíveis de forma
consecutiva -Lista Estática Sequencial- ou não consecutiva
–Lista Estática Encadeada.

Listas Dinâmicas-, mais versáteis utilizando ponteiros e

variáveis dinâmicas.

1.1 Lista Estática Sequencial

Uma lista estática sequencial é um arranjo de registos onde

estão estabelecidas regras de precedência entre seus
elementos ou é uma colecção ordenada de componentes do
mesmo tipo. O sucessor de um elemento ocupa posição física
subsequente.

Ex: lista telefônica, lista de alunos

 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
1.1 Lista Estática Sequencial (cont.)
A implementação de operações pode ser feita utilizando
matriz (vector) e record (regisro), onde o vector associa o
elemento a(i) com o índice i (mapeamento sequencial).

❑ Características de Lista Estática Sequencial

✔elementos na lista estão ordenados;
✔Elementos são armazenados fisicamente em
posições consecutivas;
✔inserção de um elemento na posição a(i)
causa o deslocamento a direita do elemento
de a(i) ao último;
✔eliminação do elemento a(i) requer o
deslocamento à esquerda do a(i+1) ao último
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
1.1 Lista Estática Sequencial (cont.)

1 2 3 ... i i+1 n-1 n

A 89 01 3 ::::: 90 4 100 -8

Primeiro elemento
Último elemento
da lista
da lista
A (1) = 89
A (2) = 01
:::::
A (i) = 90
A (n) = -8
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
1.1 Lista Estática Sequencial (cont.)
Assim as propriedades estruturadas da lista permitem
responder a questões como:
✔qual é o primeiro elemento da lista
✔qual é o último elemento da lista
✔quais elementos sucedem um determinado elemento
✔quantos elementos existem na lista
✔inserir um elemento na lista
✔eliminar um elemento da lista
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
1.1 Lista Estática Sequencial (cont.)

❑Vantagem:
✔acesso directo indexado a qualquer elemento da lista;
✔tempo constante para aceder o elemento i - depfimerá somente
do índice.
❑Desvantagem:
✔movimentação quando eliminado/inserido elemento;
✔tamanho máximo pré-estimado.
❑Quando usar:
✔listas pequenas;
✔inserção/remoção no fim da lista;
✔tamanho máximo bem definido.
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
1.1 Lista Estática Sequencial (cont.)

❑Algoritmos para manipulação da lista estática

i) Acesso a um elemento
Escrever(A[i]);
ii) Actualização
A[i]← 'Valor'

iii) Tamanho da Lista

início
tamanho ← n;
Fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
1.1 Lista Estática Sequencial (cont.)
❑Algoritmos para manipulação da lista estática

iv) Inserção de um elemento na posição i

Requer o deslocamento à direita dos elementos a(i+1)...a(n)
Procedure Inserir()
Início
Para j de n+1 até i+1 passo –1 faça
A[j] ← A[j-1];
Fim-para
A[i] ←'novo valor';
n ← n+1;
Fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
1.1 Lista Estática Sequencial (cont.)
❑Algoritmos para manipulação da lista estática

v) Remoção do i-ésimo elemento

Requer o deslocamento à esquerda dos elementos a(i+1)...a(n)

Procedure Remover()
Inicio
Para j de i até n-1 passo 1 faça
A[j]←A[j+1];
Fim-para
n←n-1;
Fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
2. Listas Dinâmicas Simples
❑Ponteiro

onde o conteúdo de P corresponderia ao endereço do objecto. Esses

endereços serão as ligações das listas encadeadas dinâmicas.

Existe o objecto composto por:

Contêm o endereço do próximo elemento

Contêm a informação do endereço P

 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
2. Listas Dinâmicas
❑Ponteiro

Para designar ponteiro, objecto e campos, a notação utilizada é:

ponteiro: p
objecto: p^
campos: p^(info)
link(p)

i) Endereço nulo (terra)

Algumas linguagens como o Pascal provêm uma constante
pré-definida para denotar o endereço nulo nil. Podemos utilizá-la
para atribuições e testes, como nos exemplos abaixo:
1: L ← nil;
2: Se (p = nil) então ...
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
2. Listas Dinâmicas
❑Ponteiro
ii) Ponteiro x Objecto Apontado
Nos exemplos abaixo, é ilustrada a diferença entre as operações de atribuição
entre ponteiros (por exemplo, p ← q ) e a atribuição entre o conteúdo dos registos
apontados pelos ponteiros (isto é: p^ ← q^.
Declarar p,q: Lista;

Do comando p q,temos a situação seguinte:

 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
2. Listas Dinâmicas
❑Ponteiro
ii) Ponteiro x Objecto Apontado

Do comando p^ q^,temos a situação seguinte:

 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
2. Listas Dinâmicas
❑Manipulação de registos
i) Declaração de Variável
Registo do tipo rec
Declarar p: ^rec;
ii) Criação de um registo
Cria uma variável ponteiro do tipo ^rec.
new(p);

a) efectivamente aloca uma variável do tipo rec

b) gera um ponteiro do ^rec apontando para aquela variável
c) atribui o ponteiro à variável p

A partir daí:
a) o ponteiro pode ser referenciado como p
b) variável referenciada por p é denotada por p^
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
2. Listas Dinâmicas
❑Manipulação de registos
iii) Atribuição de conteúdo ao registo:
p^(info) ← valor;

iv) Liberação de um registo

dispose(p)
a) operação libera o espaço apontado por p
b) p passa a ter valor indefinido

❑Definição do tipo de registo

Tipo prec = ^rec;
Lista = prec;
rec = registo;
info: T; {seu tipo preferido}
lig: Lista
Fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
2. Listas Dinâmicas

❑Definição do tipo de registo

Tipo prec = ^rec;
Lista = prec;
rec = registo;
info: T; {seu tipo preferido}
lig: Lista
Fim;

Var p: Lista; {ponteiro para qualquer elemento da

lista}
L: Lista; {ponteiro para o primeiro elemento da
lista }
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
2. Listas Dinâmicas

❑ Operações sobre Listas Dinâmicas

Por comodidade irá-se usar a seguinte notação:
P[inf] = P^(int)
P^ = Link(P) = lig (P)
i) Criação da lista vazia

Procedure Create (Var L : Lista);

Inicio
L← nil;
Fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
2. Listas Dinâmicas

❑ Operações sobre Listas Dinâmicas

ii) Inserção do primeiro elemento da lista

Procedure Insere_Prim(L, valor);

Declarar p: Lista;
Inicio
new(p);
p[info] ← valor;
Link(p) ← nil;
L ← p;
Fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
2. Listas Dinâmicas

❑ Operações sobre Listas Dinâmicas

iii) Inserção no inicio da lista
L 3) Inserção no início de uma lista
Procedure Insere_Inic(L, valor);
Declarar p: Lista;
Inicio
POSIÇÃO A INSERIR p[info] ← valor;
link(p) ← L;
L ← p;
fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
2. Listas Dinâmicas

❑ Operações sobre Listas Dinâmicas

iv) Inserção do valor v depois do elemento apontado por k

Procedure Insere_depois(L, v, k);

Declarar j: Lista;
Inicio
new(j);
J[info] ← v;
link(j) ← link(k);
link(k) ← j;
fim;
OBS: Funciona para inserção após último
elemento.
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
2. Listas Dinâmicas

❑ Operações sobre Listas Dinâmicas

v) Remoção do elemento apontado por j, que segue k
Procedure Elimina_depois(L, k, j);
Inicio
Link(k) ←link(j);
dispose(j);
fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
2. Listas Dinâmicas
❑ Operações sobre Listas Dinâmicas
vi) Eliminar um valor v de uma lista ordenada L

{ p = nil ou p^.info = v ou p^.info

Procedure Elimina(v, L);
>v}
declarar p, pa: Lista; Se (p = nil) então
acabou: booleana; Escrever("lista não contém
inicio v")
pa ← nil; Senão Se p^(info) > v então
p ← L; acabou ← (p = nil); Escrever("lista não
Enquanto (not acabou) faça contém v")
Senão Se pa = nil então
Se p^(info) < v então
L ← link(p)
pa ← p; p ← link(p); Senão
acabou ← (p = nil); Link(pa) ←
Senão link(p);
acabou ← true; {Enquanto Fim-se
acaba aqui!} Fim-se
Fim-enquanto Fim-se
dispose(p);
fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
3. Listas Duplamente encadeadas
❑ Características
✔Listas foram percorridas do início ao final.
✔Ponteiro "anterior" necessário para muitas operações.
✔Em alguns casos pode-se desejar percorrer uma lista nos dois
sentidos indiferentemente.
✔Nestes casos, o gasto de memória imposto por um novo campo
de ponteiro pode ser justificado pela economia em não
reprocessar a lista toda
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
3. Listas Duplamente encadeadas

i) Declaração

Type tpont = ^ trec;

trec = record
info:Tipoelem;
esq, dir: tpont;
Fim;
Lista = tpont;

Var pont: Lista;

 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
3. Listas Duplamente encadeadas
ii) Algoriitmos de manipulação de listas duplamente
encadeadas

a)Inserção à direita de pont

pont

Procedure ins_dir (Var pont: lista; x: Tipoelem);

Var j: Lista;
Inicio
new(j);
j^(info)←x; j(inf) X
j^(dir)←pont^(dir); LinkDir(j) LinkDir(pont)
j^((dir^)(esq)) ←j; LinkEsq(LinkDir(j)) j
j^(esq) ←pont; LinkEsq(j) pont
pont^(dir) ←j; LinkDir(pont) j
Fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
3. Listas Duplamente encadeadas

ii) Algoriitmos de manipulação de listas duplamente

encadeadas

b) Inserção à esquerda de pont

Procedure ins_esq (ptlista, x);

Declarar j: Lista;
Inicio
new(j);
j^(info) ←x; LinkDir(j) pont
j^(dir) ←pont; LinkEsq(j) LinkEsq(pont)
j^(esq) ←pont^(esq); LinkDir(LinkEsq(j)) j
j^((esq^)(dir)) ←j; LinkEsq(pont) J
pont^(esq) ←j;
Fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
3. Listas Duplamente encadeadas

ii) Algoriitmos de manipulação de listas duplamente

encadeadas

c) Eliminação à direita de pont

Procedure elim_dir (pont);
Declarar j: Lista;
Inicio
j←pont^(dir); J LinkDir(pont)
pont^(dir) ←j^(dir); LinkDir(pont) LinkDir(j)
j^(dir^(esq)) ←pont; LinkEsq(LinkDir(j)) pont
dispose(j); Dispose(j)
Fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
3. Listas Duplamente encadeadas

ii) Algoriitmos de manipulação de listas duplamente

encadeadas

c) Eliminação à direita de pont

Procedure elim_dir (pont);
Declarar j: Lista;
Inicio
j←pont^(dir); J LinkDir(pont)
pont^(dir) ←j^(dir); LinkDir(pont) LinkDir(j)
j^(dir^(esq)) ←pont; LinkEsq(LinkDir(j)) pont
dispose(j); Dispose(j)
Fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
3. Listas Duplamente encadeadas

ii) Algoriitmos de manipulação de listas duplamente encadeadas

d) Eliminação do próprio pont

Procedure elim (pont);
Inicio
pont^((dir^)(esq)) ←pont^(esq); LinkEsq(LinkDir(pont))
LinkEsq(pont);
pont^(esq^)(dir))←pont^(dir); LinkDir(LinkEsq(pont))
LinkDir(pont);
dispose(pont); Dispose(pont)
Fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
3. Listas Duplamente encadeadas
ii) Algoriitmos de manipulação de listas duplamente encadeadas

e) Busca em uma lista circular

Funtion Busca_Dup_Ord(ptlista, x):Lista;
{ Lista Duplamente Encadeada Ordenada com sentinela
apontado por ptlista }
Declarar pont, ultimo: Lista;
Inicio
ultimo←ptlista^(esq);
Se x<=ultimo^(info) então
pont←ptlista^(dir);
Enquanto pont^(info) < x faça
pont←pont^(dir);
Busca_Dup_Ord←pont;
Fim_Enquanto
Senão
Bus_ca_Dup_Ord←ptlista;
Fim_Se
Fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)

4.1 PILHA
Conceito
É uma lista na qual as operações de inserção e remoção de elementos
são executadas em somente uma das extremidades, denominada topo da
lista. Desta forma, o último elemento inserido é o primeiro a ser removido.

Esta disciplina de acesso é conhecida por LIFO - "Last In First Out", ou

em sua forma aportuguesada, UEPS - "Último a Entrar Primeiro a Sair".
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)

4.1 PILHA
As operações de inserção e remoção de elementos da pilha recebem
nomes especiais: push e pop, respectivamente.
Dada a pilha p e um item i qualquer, define-se a operação push(i,P)
como a adição do item i no topo da pilha p.
De forma similar, a operação pop(p) é definida como a operação que
remove um elemento do topo da pilha p. Por exemplo, x ← pop(p), vai
remover o elemento constante no topo da pilha p e armazená-lo na
variável x.
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)
4.1 PILHA
Definição
Dada uma pilha P=( a(1), a(2), ..., a(n) ), dizemos que a(1) é o elemento da
base da pilha; a(n) é o elemento topo da pilha; e a(i+1) está acima de a(i).

Operações Associadas:
I. criar (P) - criar uma pilha P vazia
II. inserir (x, P) - insere x no topo de P (empilha): push(P,x)
III. vazia (P) - testa se P está vazia
IV. topo (P) - acessa o elemento do topo da pilha (sem eliminar)
V. elimina (P) - elimina o elemento do topo de P (desempilha):
pop(P)
VI. VI) Devolve elemento eliminado
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)

4.1 PILHA
4.1.1 Alocação Sequencial de Pilhas

Operações

I) criar (P) - criar uma pilha P vazia

Procedure criar (topo);

inicio
topo ← 0;
fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)
4.1 PILHA
4.1.1 Alocação Sequencial de Pilhas
II) inserir (x, P) - insere x no topo de P(empilha): push (x, P)

Procedure push (x, P, topo);

inicio
Se topo = maxp então
"PILHA CHEIA"
Senão
topo ← topo + 1;
P[topo] ← x;
Fim-se
fim;

III) vazia (P) - testa se P está vazia

function vazia (topo): booleana;
inicio
vazia ← (topo = 0);
fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)
4.1 PILHA
4.1.1 Alocação Sequencial de Pilhas
IV) topo (P) - acessa o elemento do topo da pilha (sem eliminar)
Procedure top (topo_p, P, topo);
inicio
Se topo = 0 então
"PILHA VAZIA“
senão
topo_p ← P[topo];
fim-se;
fim;

V) elimina (P) - elimina o elemento do topo de P (desempilha): pop (P)

Procedure pop (P, topo);
inicio
Se topo = 0 então
"PILHA VAZIA"
senão
topo ← topo-1;
fim-se
fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)
4.1 PILHA
4.1.1 Alocação Sequencial de Pilhas

VI) Devolve elemento eliminado

Procedure pop_up (topo_p, P, topo);

Inicio
Se topo = 0 então
"PILHA VAZIA"
senão
topo_p ← P[topo]; {no caso de acesso ao elemento}
topo ← topo-1;
fim-se;
Fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)
4.1 PILHA

4.1.2 Alocação Encadeada de Pilhas

Uma outra maneira de se implementar pilhas pode ser através de
listas ligadas. A vantagem deste método é a flexibilidade que se
consegue por causa da utilização de listas ligadas. Um exemplo disto
é que diminui muito a possibilidade de se cometer um erro de
overflow, pois teoricamente não existe um limite superior para o
armazenamento em lista ligada.
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)
4.1 PILHA
4.1.2 Alocação Encadeada de Pilhas
Operações
I) criar (P) - criar uma pilha P vazia
Procedure criar (P);
inicio
p ← nil;
fim;

II) inserir (x, P) - insere x no topo de P (empilha): push(x,P)

Procedure push (x, P);
Declarar pont: pilha;
inicio
new(pont);
pont^(info) ← x;
link(pont) ← p;
p ← pont;
fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)
4.1 PILHA
4.1.2 Alocação Encadeada de Pilhas
Operações
vazia (P) - testa se P está vazia
III)
function vazia (p): boolean; i
inicio
vazia ← (p = nil);
fim;

IV) topo (P) - acede o elemento do topo da pilha (sem eliminar)

function top (p): TipoElem;
Inicio
Se (p <> nil) então
top ← p^(info)
fim_se
fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)
4.1 PILHA
4.1.2 Alocação Encadeada de Pilhas
Operações
IV)vazia (P) - testa se P está vazia
function vazia (p): boolean; i
inicio
vazia ← (p = nil);
fim;

V) topo (P) - acede o elemento do topo da pilha (sem eliminar)

function top (p): TipoElem;
Inicio
Se (p <> nil) então
top ← p^(info)
fim_se
fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)
4.1 PILHA
4.1.2 Alocação Encadeada de Pilhas
Operações
VI) Elimina (P) - elimina o elemento do topo de P (desempilha) : pop(P)

Procedure pop ( p);

Declarar aux: pilha;
inicio
Se (p <> nil) então
aux ← p;
p ← link(p);
dispose (aux);
fim-se
fim.
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)

4.2 FILA
Conceito
É uma lista na qual os itens componentes devem ser eliminados somente
em uma extremidade denominada início da fila, e os itens somente
podem ser inseridos na outra extremidade, denominada final da fila.

A disciplina de acesso que rege a inserção e remoção de elementos em

uma fila é denominada FIFO ("First In First Out"), ou em sua forma
aportuguesada, PEPS ("Primeiro a Entrar Primeiro a Sair").

A figura abaixo apresenta uma fila em diversos momentos distintos:

 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)

4.2 FILA

Assim como nas pilhas, existem 3 operações primitivas

principais que podem ser aplicadas em uma fila: inserção
de elementos, remoção e verificação de fila vazia.
Operações associadas:
I) Criar (F) - criar uma fila F vazia
II) Inserir (x, F) - insere x no fim de F
III) Vazia (F) - testa se F está vazia
IV) Primeiro (F) - acessa o elemento do início da fila
V) Elimina (F) - elimina o elemento do início da fila
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)

4.2 FILA

4.2.1 Implementação Sequencial de Fila

Começo Fim

Posição a remover Posição a inserir

F: fila;
Começo, {posição anterior ao primeiro elemento}
Fim: índice; {posição do último elemento}
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)

4.2 FILA

4.2.1 Implementação Sequencial de Fila

Operações com Filas

I) Criar (F) - criar uma fila F vazia

Procedure CriaFila (F);
Inicio
Começo← 0;
Fim ← 0;
Fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)

4.2 FILA
4.2.1 Implementação Sequencial de Fila
Operações com Filas

II) Inserir (x, F) - insere x no fim de F

Procedure Inserir (x:int;F);
Inicio
Se Fim < maxfila Então
Fim ← Fim + 1;
F[Fim] ←x;
Senão
escrever “fila cheia” { OVERFLOW }
Fim_Se
Fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)

4.2 FILA
4.2.1 Implementação Sequencial de Fila
Operações com Filas
III) Vazia (F) - testa se F está vazia
Function Vazia (F): Boolean;
Inicio
Se Começo = Fim Então
Vazia True {FILA VAZIA}
Fim;

IV) Primeiro (F) - acede o elemento do início da fila

Function Primeiro (F): TipoElem;
Inicio
Primeiro ← F[Começo + 1];
Fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)

4.2 FILA
4.2.1 Implementação Sequencial de Fila
Operações com Filas
V) Acesso ao primeiro elemento da Fila F
Procedure Consulta (F);
Declarar Y: TipoElemento
Inicio
Se (Começo = Fim) Então
escrever “Fila Vazia” {FILA VAZIA}
Senão
Y ← F (Começo + 1);
Fim;
 Capitulo II
Formas de Acesso e manipulação de dados – Estrutura de
dados Lineares
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)

4.2 FILA
4.2.1 Implementação Sequencial de Fila
Operações com Filas
VI) Elimina (F) - elimina o elemento do início da fila
Procedure Eliminar (Começo, Fim);
Inicio
Se (Começo = Fim) Então
escrever “Fila Vazia” {FILA VAZIA}
Senão
Começo ← Começo + 1;
Fim;
 Capitulo II
Listas
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)

4.2 FILA

4.2.2 Implementação Encadeada de Fila

Tipo Elemento:: reg(inf:dado, link:ref elemento)

Tipo fila_lista::reg(começo, fim:ref elemento)
Tipo Aux::ref elemento
Var K:Aux
Var x, y: Dado
 Capitulo II
Listas
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)

4.2 FILA

4.2.2 Implementação Encadeada de Fila

Operações com Filas

I) Criar (F) - criar uma fila F vazia

Procedure CriaFila (F);
Inicio
Começo← Nil;
Fim ← Nil;
Fim;
 Capitulo II
Listas
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)
4.2 FILA

4.2.2 Implementação Encadeada de Fila

II) Inserção de um elemento na Fila F

Procedure Inserir (F, X, K);
Inicio
New (K)
K(inf) X
link (K) ← Nil
Se Fim < > Nil então
link(Fim) K
Fim K
Fim_Se
Se (começo = Nil) e (Fim = Nil) então
Começo K
Fim K
Fim_Se
Fim;
 Capitulo II
Listas
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)
4.2 FILA
4.2.2 Implementação Encadeada de Fila

III) Remoção de um elemento na Fila F

Procedure Remover(F)
Declarar K :Aux
Inicio
Se Começo = Nil então
“Fila vazia”
Senão
K Começo
Começo Link(começo)
link(K) Nil
Dispose(K)
Se (começo = Fim então
Começo Nil
Fim Nil
Fim_Se
Fim_Se
Fim
 Capitulo II
Listas
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)
4.2 FILA
4.2.2 Implementação Encadeada de Fila

IV) Acesso ao primeiro elemento da Fila F

Function Primeiro(F)
Inicio
Se Começo = Nil então
escrever “Fila vazia”
Senão
Primeiro Começo(inf)
Fim_Se
Fim
 Capitulo II
Listas
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)
4.2 FILA
4.2.2 O problema de Implementação da fila

O que acontece com a fila considerando a seguinte sequência de

operações sobre uma fila onde se executam as seguintes operações:

IEIEIEIEIE. (I - inserção e E - eliminação)

A fila terá sempre 1 ou 0 elementos, no entanto num certo instante:

Ou seja, apenas um elemento na fila, o qual ocupa a última posição do

array!
Na próxima inserção, teremos uma condição de overflow e a fila está vazia !
Alternativa: no algoritmo de eliminação após a actualização de Começo,
verificar se a fila ficou vazia, i.e, Começo = Fim; se este for o caso,
reinicializar Começo = Fim ← 0;
 Capitulo II
Listas
4. LISTAS COM DISCIPLINAS DE ACESSO ( PILHA e FILA)
4.2 FILA
4.2.2 O problema de Implementação da fila

Procedure Eliminar (Começo, Fim);

O que aconteceria se a
Inicio
sequência fosse
Se ( Começo = Fim) Então
IIEIEIEIEI...
{FILA VAZIA}
A lista estaria com no
Senão
máximo dois elementos,
mas ainda ocorreria
Começo ← Começo + 1;
overflow com a lista quase
Se Começo = Fim Então
vazia.
Começo ← 0; Alternativa: Forçar Fim
Fim ← 0; a usar o espaço
Fim; liberado por Começo
Fim; (Fila Circular)
Fim;
 Capitulo III
Estrutura de Dados não lineares
I) Árvores

1. Introdução

Árvores são estruturas de dados não lineares que caracterizam uma

relação de hierarquia entre os dados (nós) que as compõem, onde
um conjunto de dados pode se apresentar hierarquicamente
subordinado a outro conjunto de dados.

Por definição, uma árvore é um conjunto finito A composto de um ou

mais nós, tal que:
▪ Existe um nó denominado raiz da árvore;
▪ os demais nós formam n >= 0 conjuntos S1, S2,...,Sn, onde cada
um destes conjuntos é uma árvore. Estes conjuntos S1, S2,...,Sn
recebem o nome de subárvores.
 Capitulo III
Estrutura de Dados não lineares
I) Árvores

1. Introdução (cont.)

Esquematicamente, uma árvore pode ser representada da seguinte

maneira

Os círculos representam os nós da árvore, cuja raiz é o nó A.

 Capitulo III
Estrutura de Dados não lineares
I) Árvores

2. Terminologia
O no de subárvores de
um nó é o grau daquele
nó.

O nível do nó é definido da
seguinte maneira: a raiz
tem nível 1, e este vai
aumentando, a medida
que desce-se para as
folhas.

A altura de uma árvore é

igual ao seu número de
níveis. Assim sendo, a altura
do exemplo colocado acima é
igual a 4.
 Capitulo III
Estrutura de Dados não lineares
I) Árvores

2. Terminologia (cont.)

Uma árvore ordenada é

aquela na qual os filhos de
cada nó estão ordenados.
Assume-se que esta
ordenação se desenvolva da
esquerda para a direita.
Ver o exemplo

Duas árvores não ordenadas

são consideradas isomorfas
quando puderem se tornar
coincidentes através de uma
permutação na ordem das
subárvores de seus nós.
 Capitulo III
Estrutura de Dados não lineares
I) Árvores

3. Representações Básicas para Árvores

3.1. Diagrama de Inclusão

3.2. Representação Hierárquica

 Capitulo III
Estrutura de Dados não lineares
I) Árvores

3. Representações Básicas para Árvores

3.3. Diagrama de Barras

3.4. Parêntesis Aninhados

(A (B) (C (D (G) (H)) (E) (F (I))))

 Capitulo III
Estrutura de Dados não lineares
I) Árvores

3. Representações Básicas para Árvores

3.5 Representação Matricial

Índice Informação 1a Subárvore 2a Subárvore 3a Subárvore

1 A 2 3 0

2 B 0 0 0

3 C 4 5 6

4 D 7 8 0

5 E 0 0 0

6 F 9 0 0

7 G 0 0 0

8 H 0 0 0

9 I 0 0 0
 Capitulo III
Estrutura de Dados não lineares
I) Árvores

3. Representações Básicas para Árvores

3.5 Representação Matricial

No caso da representação matricial, o nó raiz da árvore ocupa a

primeira linha da matriz. Quando alguma das subárvores de um
nó raiz se apresentar vazia, a coluna do índice correspondente
desta subárvore vale 0. Um nó folha apresenta todas as colunas
de suas subárvores iguais a 0.
 Capitulo III
Estrutura de Dados não lineares
I) Árvores

4. Árvores Binárias
4.1 Definição
Árvores binárias são estruturas do tipo árvores, onde o grau de cada nó é
obrigatoriamente menor ou igual a 2. Além disso, as subárvores de um nó têm de estar
divididas em subárvores esquerda e direita. A figura abaixo apresenta uma árvore
binária.
 Capitulo III
Estrutura de Dados não lineares
I) Árvores

4. Árvores Binárias
4.2 Tipos de Árvores
❑Àrvore estritamente
binária, é aquela em que
cada nó possui
exactamente 0 ou 2 nós
(ver item a).

❑Árvore binária completa, é

aquela que apresenta a
❑ Árvore binária cheia é aquela em que, se v seguinte propriedade: se v é
apresenta uma de suas subárvores vazia um nó tal que alguma
então v se encontra obrigatoriamente no subárvore de v é vazia, então v
último nível da árvore. Pode-se afirmar que se localiza no penúltimo ou
uma árvore binária cheia também é último nível da árvore. O item b)
completa e estritamente binária. O item c) apresenta uma árvore binária
da figura abaixo apresenta uma árvore completa.
binária cheia.
 Capitulo III
Estrutura de Dados não lineares
I) Árvores

4. Árvores Binárias
4.2 Tipos de Árvores

❑Árvores binárias ziguezague ou degeneradas são aquelas que apresentam

sempre a altura h máxima possível dados os n nós da árvore. A figura abaixo
apresenta diferentes árvores ziguezague.
 Capitulo III
Estrutura de Dados não lineares
I) Árvores

4. Árvores Binárias
4.3 Caminhamento em Árvore Binária

Um caminhamento é a habilidade de se mover através de todos os seus nós. Cada

caminhamento impõe uma ordenação sobre os nós da árvore, isto é, a ordem na qual eles
são acedidos. Dos diversos tipos de caminhamentos definidos, os três principais (central,
pré-fixado e pós-fixado)

a) Caminhamento Pré-Ordem ou c) Caminhamento Pós-Ordem ou

Pré-Fixado:
1) Visite a Raiz;
2) Visite a Subárvore Esquerda;
3) Visite a Subárvore Direita;
b) Caminhamento Central:
Pós-Fixado:
1) Visite a Subárvore Esquerda;
2) Visite a Subárvore Direita;
3) Visite a Raiz;

1) Visite a Subárvore Esquerda;

2) Visite a Raiz;
3) Visite a Subárvore Direita;
 Capitulo III
Estrutura de Dados não lineares
I) Árvores

4. Árvores Binárias
4.3 Caminhamento em Árvore Binária

Exemplos:
 Capitulo III
Estrutura de Dados não lineares
I) Árvores

5. Aplicações de Árvores Binárias

A estrutura de árvore binária pode ser utilizada em casos onde os dados

ou objectos a serem representados possuem uma relação de hierarquia
entre si, como por exemplo no caso da expressão matemática abaixo:
a * b + c / (d + e)
onde a relação hierárquica aparece na medida em que alguns operadores
da expressão têm maior precedência sobre outros, tornando possível a
sua representação através da seguinte árvore binária:
A execução na árvore é
feita considerando a
prioridade dos operadores.
 Capitulo III
Estrutura de Dados não lineares
I) Árvores

5. Aplicações de Árvores Binárias (cont.)

Outra aplicação de árvore binária é a ordenação e pesquisa de

conjuntos de dados. Estas árvores são denominadas árvores binárias
de busca ou de pesquisa/ordenação (ABPO).
 Capitulo III
Estrutura de Dados não lineares
I) Árvores

6. Árvores de Busca ou de Pesquisa e Ordenação

O processo de colocação um elemento do conjunto de dados na árvore

obedece a seguinte regra:
a) se a árvore estiver vazia, o elemento é colocado na raiz da árvore;
b) caso contrário, se o elemento for menor ou igual ao elemento da raiz,
ele é posicionado à esquerda deste.
Se o elemento for maior do que o da raiz, ele é posicionado à direita da
mesma.
42-51-19-37-42-86-71-10-75-22-31-42

O caminhamento central na árvore devolve

os elementos em ordem crescente.
 Capitulo III
Estrutura de Dados não lineares
I) Árvores

7. Implementação de Árvores Binárias de Busca

Da mesma maneira como implementamos as listas encadeadas em algoritmos
genéricos com o auxílio da alocação dinâmica, também as árvores binárias podem ser
implementadas da mesma maneira.

Esquematicamente:
 Capitulo III
Estrutura de Dados não lineares
I) Árvores

7. Implementação de Árvores Binárias de Busca

Por exemplo em Pascal, a estrutura necessária para se representar uma árvore

binária seria:

type ptr = ^nó;

nó = record
item : integer;
esq : ptr;
dir : ptr;
end; {record}
var raiz : ptr;

onde o campo item tem a função de guardar o elemento a ser armazenado no nó da

árvore; o campo esq guarda o endereço do filho à esquerda do nó e o campo dir
guarda o endereço do filho à direita do nó.
 Capitulo III
Estrutura de Dados não lineares
I) Árvores

7. Implementação de Árvores Binárias de Busca

Em uma árvore binária de busca existem basicamente 4 operações que podem ser
efetuadas:

i) caminhamento (pré-fixado, central e pós-fixado);

ii) inserir um novo elemento na árvore;
iii) pesquisar um elemento na árvore
iv) remover um elemento da árvore.

7.1. CAMINHAMENTO
Atravês de procedimentos recursivos se implementam os caminhamento:

7.1.1. Caminhamento Pré-Fixado

procedure PreFix(raiz);
Início
Se raiz <> NIL então
Escrever(raiz^.item);
PreFix(raiz^.esq);
PreFix(raiz^.dir);
Fim-se
Fim; { procedure PreFix }
 Capitulo III
Estrutura de Dados não lineares
I) Árvores

7. Implementação de Árvores Binárias de Busca

7.1. CAMINHAMENTO (CONT.)

7.1.2. Caminhamento Central 7.1.3. Caminhamento Pós-Fixado

procedure Central(raiz); procedure PosFix(raiz);

Início Início
Se raiz <> NIL Então Se raiz <> NIL então

Central(raiz^.esq); PosFix(raiz^.esq);
Write(raiz^.item); PosFix(raiz^.dir);
Central(raiz^.dir); Write(raiz^.item);
Fim-se; Fim-se;
Fim; { procedure Central } Fim; { procedure PosFix }
 Capitulo III
Estrutura de Dados não lineares
I) Árvores
7. Implementação de Árvores Binárias de Busca
7.2. INSERÇÃO
No caso da inserção de elementos em uma árvore binária de ordenação e pesquisa, o
esquema seria:
procedure InsArv(raiz, nó_aux);
Início
Se raiz = NIL então
raiz ← no_aux
Senão
Se no_aux^.item <= raiz^.item
então
InsArv(raiz^.esq, no_aux)
Senão
InsArv(raiz^.dir, no_aux);
Fim-se;
Fim-se;
end; {Procedure InsArv}
 Capitulo III
Estrutura de Dados não lineares
I) Árvores
7. Implementação de Árvores Binárias de Busca
7.3. PESQUISA
O esquema genérico para a operação de pesquisa de um elemento qualquer dentro da
árvore de busca seria:
procedure PesqArv(raiz, chave, posição);
Início
Se raiz = NIL então
posição ← NIL
Senão
Se raiz^.item = chave {achou}
posição ← raiz
Senão
Se chave <= raiz^.item then {pesquisa à
esquerda}
PesqArv(raiz^.esq, chave, posição)
Senão { pesquisa à direita}
PesqArv(raiz^.dir, chave, posição);
Fim-se;
Fim-se;
Fim-se
Fim; {PesqArv}
 Capitulo III
Estrutura de Dados não lineares
I) Árvores
7. Implementação de Árvores Binárias de Busca
7.3. PESQUISA

A variável posição devolve o endereço do elemento encontrado na

árvore, ou então NIL, tanto no caso da árvore estar vazia ou então do
elemento não ter sido encontrado na árvore. A chamada a procedure
PesqArv seria:
.....
.....
PesqArv(raiz, 20, ponteiro);
Se ponteiro = NIL então
Escrever("O elemento não existe na árvore")
Senão
Escrever("O elemento 20 da árvore: ", ponteiro^.item);
.....
.....
 Capitulo III
Estrutura de Dados não lineares
I) Árvores
7. Implementação de Árvores Binárias de Busca
7.4. REMOÇÃO
Das operações em árvores binárias de busca, a remoção é a mais complexa
por necessitar de fazer rearranjos na árvore:
Deve-se considerar 2 possibilidades distintas:

a) quando o nó a ser removido possui uma ou ambas as subárvores vazias;

b) quando o nó a ser removido possui ambas as subárvores ocupadas.
 Capitulo III
Estrutura de Dados não lineares
I) Árvores
7. Implementação de Árvores Binárias de Busca
7.4. REMOÇÃO
Para o último caso, onde ambas as subárvores do nó a ser removido estão
ocupadas, uma das soluções é fazer o ponteiro do nó a ser removido
apontar para a sua subárvore da direita, e realocar a sua subárvore da
esquerda, de modo que ela se coloque mais a esquerda possível da
subárvore da direita. Muito embora, a primeira vista possa parecer
complicado, a figura a seguir com certeza ajuda a desvendar o mistério, sendo
que o nó removido é o de no 8.
 Capitulo III
Estrutura de Dados não lineares
I) Árvores
7.4. REMOÇÃO
Senão {ambas as subárvores estão ocupadas}
procedure DeletaElementoDaArvore
(posição); temp ← posição^.dir;
Declarar temp : ptr; Enquanto temp^.esq <> NIL Faça
Início { procura a posição mais a esquerda
Se posição = NIL então possível na subárvore da direita }
Escrever("Erro, o nó a ser removido não temp ← (temp^.esq);
existe") Fim-enquanto
Senão temp^.esq ← posição^.esq;
Se posição^.dir = NIL então {liga esta posição na subárvore da
esquerda }
temp ← posição; temp←posição;
posição ← posição^.esq posição ← posição^.dir;
≡ LinkEsq(Posição); { liga o avô com o neto da direita }
dispose(temp); dispose (temp);
Fim-se;
Senão Fim-se;
Se posição^.esq = NIL então Fim-se;
(LinkEsq(Posição) Fim-se;
temp ← posição; Fim; {proc DeletaElementoDaArvore }
posição ← posição^.dir;
≡ LinkDir (Posição)
dispose(temp);
 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

1. Definição

Um grafo propriamente dito é uma representação gráfica das relações

exitentes entre elementos de dados. Ele pode ser descrito num espaço
euclidiano de n dimensões como sendo um conjunto V de vértices e um
conjunto A de curvas contínuas (arestas).

Um vértice é representado por um círculo e uma curva é representada

pela representação gráfica plana característica, ou seja, um segmento
de reta. Quando uma curva possui indicação de sentido (uma seta), ela
é chamada de arco , caso contrário é chamada de linha .

As principais características desta estrutura são:

1. toda curva fechada de A tem apenas um ponto de V

2. toda curva aberta de A tem exatamente dois pontos de V
 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

1. Definição (cont.)
3. as curvas de A não têm pontos comuns excepto os elementos do conjunto V .

❑ Quando um grafo possui arcos, o mesmo denomina-se grafo

dirigido ou dígrafo .

❑ Quando um elemento do conjunto A (curvas) tem o mesmo

elemento do conjunto V (vértices) como ponto inicial e final,
dizemos que este elemento é um laço .
 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

2. Operações Sobre Grafos

2.1. Operações elementares

Inserção de uma curva ou vértice

Retirada ou Eliminação de curvas e/ou vértices;

Rotação ou redesignação dos vértices pela troca entre eles num
dos sentidos;

Fusão ou junção de dois vértices em um;

Inversão ou troca do sentido dos arcos.

 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

2. Operações Sobre Grafos

2.2. Operações Binárias

São operações como as realizadas na Teoria dos Conjuntos. Seu objectivo

é fazer operações sobre os elementos dos grafos (vértices e arestas).

Sejam os grafos G1(V1, A1), G2(V2, A2) e G3(V3, A3), onde V1, V2 e V3
são os conjuntos de vértices e A1, A2 e A3 são os conjuntos de arestas
dos grafos.
 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

2. Operações Sobre Grafos

2.2. Operações Binárias

A. União

É a junção de dois grafos através de vértices em comum, se existentes.

G'(V', A') U G"(V", A") = G(V, A), V = V' U V" e A = A' U A".
Ex.:
 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

2. Operações Sobre Grafos

2.2. Operações Binárias

B. Intersecção
Tem como resultado os elementos em comum entre dois grafos.

C. Diferença
 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

3. Caracterização dos grafos

3.1. Cardinalidade
A cardinalidade de um conjunto de vértices é igual à quantidade de
seus elementos. É também chamada de ORDEM.
Ex.:

C(V) = 4

A cardinalidade de um conjunto de curvas é igual ao número e elementos

que o compõe. Ex.: Para G(V, A) do exemplo anterior: C(A) = 4.
 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

3. Caracterização dos grafos

3.2. Vértices Adjacentes
Dois vértices são adjacentes se existir uma curva entre eles. Dado dois nós x e y,
a representação de uma linha é dada por xy e de um arco por xy.

3.3. Vértices Conexos

Dois vértices são conexos se são adjacentes ou possuem uma relação de
adjacência, ou seja, dados dois vértices x e y, existe um nodo x1 que é adjacente
a x, outro x2 que é adjacente a x1, e assim sucessivamente.

Ex: No grafo C é anexo a D

 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

3. Caracterização dos grafos

3.4. Cadeia

É um conjunto qualquer de linhas de um grafo.

Ex.: Para o exemplo anterior, são cadeias DAB, CB.

3.5. Ciclo
É uma cadeia fechada, onde a extremidade inicial e final coincidem.

Ex: os ciclos ABCDA E CBADC foram retirados do grafo.

 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

3. Caracterização dos grafos

3.6. Caminho

É um conjunto qualquer de arcos de um grafo.

Ex: para o grafo são caminhos DA e BCDA

 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

4. Tipos de Grafos

4.1. Grafo parcial

Se G2 é um grafo parcial de G1, então G2 possui um mesmo conjunto de vértices,
mas não o mesmo de arestas, do grafo G1.

Ex:

4.2. Subgrafo
Se o grafo G2 é um subgrafo de G1, então G2 possui um número de vértices
inferior aos de G1, embora mantendo o número de curvas entre os vértices
existentes.

Ex:
 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

4. Tipos de Grafos

4.3. Subgrafo parcial

Se o grafo G2 é um subgrafo parcial de G1, então G2 é um subgrafo que não

mantém todas as curvas entre os vértices existentes.

Ex:
 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

4. Tipos de Grafos

4.4. Grafo valorado

É o grafo que possui valores nos vértices e nas curvas.

Ex:
 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

5. Representação dos Grafos

Há diversas formas de representação de grafos em estruturas de dados:

podemos representar as adjacências entre os vértices, as arestas, e
assim por diante. A seguir analisa-se a forma de representação através
da matriz de adjacências e lista de adjacências , onde descreve-se a
relação entre os vértices.

5.1. Matriz de Adjacências

Podemos representar um grafo através de uma matriz de dimensão C(V)
x C(V), onde o conteúdo poderá ser de números binários (0;1) ou inteiros
(-1;0;1).
 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

5. Representação dos Grafos

5.1. Matriz de Adjacências
Ex:

m(i,j)

A cardinalidade de vértices do grafo G é 6, portanto, para sua representação,

deveremos ter uma matriz de adjacências 6x6. Utilizando valores binários, podemos
representar desta forma:

Regra: ma[i,j] = 1, se i é adjacente a j, 0 caso contrário .

A está conectado com B , mas não o contrário, por isso ma[A,B] é 1 e
ma[B,A] é 0.
 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

5. Representação dos Grafos

5.1. Matriz de Adjacências (-1,0,1)
Ex: A representação que clarifica origem e
destino e a matriz: ma[i,j] = -1 se i é origem
da adjacência com j, 1 se i é o destino da
adjacência com j e 0 para os demais
vértices não envolvidos na adjacência .
Isso é sintetizado na seguinte matriz:

Como exemplo, observemos o elemento

ma[A,B] , ma[A,C] e ma[A,D] , que
possuem valor -1. Isto indica que A é
origem de arcos para C , D e E . Também
observemos ma[F,D] e ma[F,E] , com valor m(i,j)
1, indicando que F recebe os arcos de D e.
 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

5. Representação dos Grafos

5.2. Lista de Adjacência
Ex:

Para que seja possível a remodelagem de um grafo em tempo de execução, torna-se

necessária a alocação dinâmica de sua representação. Por isso, a representação de
adjacências entre vértices pode ser feita através de listas lineares.

A lista encadeada é formada por nodos que contém o dado do vértice (letra)
e o ponteiro para o vértice adjacente ao indicado no índice (vector descritor
dos vértices).
 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

5. Representação dos Grafos

5.3 Matriz de Incidência

Este tipo de matriz representa um grafo a partir de suas arestas. Como exige muitas vezes a
alocação de uma matriz maior do que no método da matriz de adjacências, não é tão
utilizada quanto aquela. A matriz alocada deverá ter dimensões C(V) x C(A).

M[I,j] =

O princípio desta representação está na regra:

mi[i,j] = 1 se o vértice i incide com a aresta j,
0 caso contrário . Exemplificando a partir do
grafo G anteriormente apresentado, teremos
uma matriz:
 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

6. Caminhamento em Grafos
6.1. Caminhamento em Amplitude

a ordem de visita, se for escolhido inicialmente o

vértice C, o adjacente será D (primeiro da fila). Como
não há outro vértice adjacente, escolhe-se o primeiro
da fila (D) para recomeçar o processo. O adjacente a
D é B, o qual vai para a fila. E novamente não há outro
adjacente, então escolhe-se o primeiro da fila, que é B.
Repete-se o processo, visitando-se A, que vai para a
fila. Mais uma vez, recomeça as visitas a partir de A,
que era o primeiro da fila. Visita-se B, mas verifica-se
que ele já está marcado como visitado. Então, visita-se
C, mas ele também já foi marcado. Finalmente,
visita-se D, que também já foi visitado, encerrando,
Grafo K então o caminhamento. A ordem de caminhamento
pode ser vista ao lado.

O caminhamento em amplitude é realizado quando

há interesse em avaliar-se todos os vértices principais
antes de suas derivações posteriores.
 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

6. Caminhamento em Grafos
6.2. Caminhamento em Profundidade

Este tipo de caminhamento é feito quando pretende-se explorar ao

máximo determinada ramificação do grafo. Seu algoritmo é composto
pelos passos:

Escolhe-se um vértice inicial;

visita-se um primeiro vértice adjacente, marcando-o como visitado;
coloca-se o vértice adjacente visitado numa pilha;
o vértice visitado torna-se o novo vértice inicial;
repete-se o processo até que o vértice procurado seja encontrado ou
não haja mais vértices adjacentes. Se verdadeiro, desempilha-se o topo
e procura-se o próximo adjacente, repetindo o algoritmo;

O processo termina quando o vértice procurado for encontrado ou

quando a pilha estiver vazia e todos os vértices tiverem sido visitados.
 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

6. Caminhamento em Grafos
6.2. Caminhamento em Profundidade

Grafo T

A seqüência de caminhamento inicia com a escolha de um vértice, digamos, A. Sendo A o vértice

inicial, visita-se primeiro um de seus vértices adjacentes, por exemplo, B. Empilha-se A e B
torna-se o novo vértice inicial. Mais uma vez, escolhe-se um adjacente, no caso há só um, E.
Empilha-se B e E torna-se o novo vértice inicial. Como não há mais vértices adjacentes,
desempilha-se o topo, ou seja, B. Mas B também não tem mais adjacentes, então desempilha-se
A, o qual possui C como novo adjacente. Então C torna-se o novo vértice inicial, empilhando-se
novamente A. O vértice adjacente F é escolhido e C é empilhado. Como F não tem adjacentes,
desempilha-se C e visita-se D. O vértice C é empilhado novamente e D é o novo inicial. Como seu
adjacente já foi visitado, desempilha-se C. Como C não tem mais adjacentes, desempilha-se A.
Como A não tem mais adjacentes, termina a busca. O grafo abaixo indica a ordem de visitação.
 Capitulo III
Estrutura de Dados não lineares
II) GRAFOS

6. Caminhamento em Grafos
6.2. Caminhamento em Profundidade
 Capitulo IV
ORDENAÇÃO
1. Introdução

O objectivo da ordenação dos elementos de uma estrutura de dados, é

facilitar e aumentar a eficiência das operações de pesquisa sobre esses
dados. A ordenção pode ser crescente ou decrescente. O problema a
ser resolvido com a ordenação é o seguinte:

Entrada: sequência de n números <a1,a2, …, an>

Saída: sequência dos n números de entrada reordenada, gerando <a1’,
a2’, …, an’>
de forma que: a1’≤ a2’, …, ≤ an’ (para o caso de ordenação crescente) ou
a1’≥ a2’, …, ≥ an’ (para o caso de ordenação decrescente).
 Capitulo IV
ORDENAÇÃO
1. Introdução

No presente texto serão abordados os seguintes métodos de ordenação

interna:
1. Ordenação por Inserção
- inserção directa
-incrementos decrescentes (Shell sort)

2. Ordenação por Troca

- método da bolha (Bubble sort)
- método da troca e partição (quicksort)

3. Ordenação por Selecção

- selecção directa
- selecção em árvore (heapsort)
 Capitulo IV
ORDENAÇÃO
2. Ordenação por Inserção

Nesse método os elemntos são inseridos na sua posição correcta, em

relação aos elementos já classificados.

2.1. Inserção Directa

É o método mais simples, utilizado para um conjunto pequeno de dados.
Possui baixa eficiência. Nesse método o vector a ser ordenado é
dividido em dois segmentos: o primeiro segmento contém os elemntos já
ordenados; e o segundo segmento contém os elemntos a serem
ordenados.
Algoritmo:
-Primeiro elemento está no vector ordenado e os demais no vector
desordenado;

-Retirar o primeiro elemento do vector desordenado e colocá-lo no

vector ordenando, na sua posição correcta;

- Repetir o processo para todos os elementos do vector desordenado.

 Capitulo IV
ORDENAÇÃO
2. Ordenação por Inserção
2.1. Inserção Directa.
Const
TAM = 10 Exemplo:
Tipos 5| 2 3 4 8 7
V = vector[1..TAM] de inteiros 2 5 |3 4 8 7
Var 2 3 5 |4 8 7
Vet:v 2 3 4 5 | 8 7
I, j, k, temp: inteiro 2 3 4 5 8 | 7
Achei:Logico 2 3 4 5 7 8
Inicio
Para i = i até TAM Faça
Leia (vet[i])
Fim-Para
Para j = 2 até TAM Faça
Chave = vet[j]
i=j–1
Enquanto (i > 0) e (vet[i] > chave) Faça
Vet[i + 1] = vet[i]
i=i–1
Fim-Enquanto
Vet[i + 1] = chave
Fim-Para
Fim.
 Capitulo IV
ORDENAÇÃO
2. Ordenação por Inserção
2.2. Incrementos Decrescentes (Shell sort)
Proposto por Ronaldo L. Shell (1959), é uma extensão do algoritmo de inserção directa.
A diferença com relação à inserção directa é o número de segmentos do vector. Na inserção
directa é considerado umúnico segmento do vector onde os elementos são inseridos
ordenadamente. No método do Shell são considerados diversos segmentos.
A ordenação é realizada em diversos passos. A cada passo está associado um
incremento I, o qual determina os elementos que pertencem a cada um dos segmentos:
- segmento 1 – vet[1], vet[1+I], vet[1+2I],...
- segmento 2 – vet[2], vet[2+I], vet[2+2I],...
...
segmento k – vet[k], vet[k+I], vet[k+2I],...

A cada passo todos os elementos (segmentos) são ordenados isoladamente por

inserção directa. No final de cada passo o processo é repetido para um novo incremento I
igual a metade do anterior, até que seja executado um passo com incremento I=1. O valor do
incremento I é sempre uma potência inteira de 2. O valor do incremento inicial é dado por 2 **
NP, onde NP é o número de passos para ordenar o vector ( fornecido pelo usuário, NP é uma
aproximação incial ).
 Capitulo IV
ORDENAÇÃO
2. Ordenação por Inserção
2.2. Incrementos Decrescentes (Shell sort)
Assim, para NP = 3 o valor do incremento em cada passo seria:
- I = 2 ** 3 =8
- I = 2 ** 2 =4
- I = 2 ** 1 =2
-I = 2 ** 0 =1

::::::::::::::::::::::::::::::::;;;
 Capitulo IV
ORDENAÇÃO
2. Ordenação por Inserção
Algoritmo:
const
TAM = 12
Tipos
v = vector [1..TAM] de inteiros
var
vet: v
np, i, j, inc : inteiro
Início
Para i = 1 até TAM Faça
Leia (vet [i] )
Fim - Para

Leia (np)
Para i = np até 0 passo -1 Faça
Inc = 2 * * i
Para j = 1 até inc Faça
Método_Shell (vet, inc, j, TAM)
Fim_Para
Fim-Para
Fim.
 Capitulo IV
ORDENAÇÃO
2. Ordenação por Inserção
Procedimento Metodo_shell (Ref vet, r, s, n)
Inicio
Var

i, j, k, temp: inteiro vet[j] = temp

achei: lógico
Fim_se
Para i = (s + r) até n passo r Faça Fim_para
J = s Fim _Método_Shell
achei = FALSO
Enquanto ( j < i) E (Não achei)
Se vet [i] < vet [j] então
Achei = VERDADE
Senão
j = j + r
Fim_se
Fim enquanto
Se achei Então
temp = vet [i]
k = i + r
Enquanto k > (j - r) Faça
Vet [k + r] = vet[k]
k= k - r
Fim_enquanto
 Capitulo IV
ORDENAÇÃO
3.Ordenaçao por Troca

Numa abordagem, durante o caminhamento no vector, se os dois elementos são encontrados

fora de ordem, suas posições são trocados. São realiazadas comparações sucessivas de pares
de elementos. A estratégia de escolha de pares de elementos estabelece a diferença entre os
dois métodos de ordenação por troca.

3.1 Método da Bolha (bubble sort)

É um método bastante simplis, porém lento. Onome bolha se deve ao fato de que os flutuam
até a sua corecta posição como bolhas. O Algorítmo é o seguinte:

- A cada passo, cada elemento é comparado com o próximo, Se o elemento estiver fora de
ordem, a troca é realizada
- Realizam-se tantos passos quantos necessários até que não ocorram mais trocas.

Obs. Logo no primeiro passo o mair valor vai para o fim.

 Capitulo IV
ORDENAÇÃO
3.Ordenaçao por Troca

Algorítmo
Enquanto troca Faça
Const Troca = FALSO
TAM = 20 Para i = 1 até lim Faça
Tipos Se vet[i] > vet [ i +1 ] então
tem = vet[i]
V = vector [1...TAM] de inteiros vet [i] = vet [ i + 1 ]
Var vet [ i + 1 ] = tem
Vet: v k= i
i, temp, lim , k: inteiro troca = verdadeiro
Troca: lógica Fim-se
Início Fim-para
Para i = 1 até TAM Faça Lim = k
Leia (vet[i]) Fim-enquanto
Fim _Para Fim.
Troca = VERDADEIRO
Lim = TAM – 1
 Capitulo IV
ORDENAÇÃO
Exemplo: 500 85 515 60 910 170 890 275 650 430

Passo 1: 85 500
60 515
170 910
890 910
257 910
650 910
430 910
85 500 60 515 170 890 275 650 430 910
Passo 2: 85 60 500 170 515 275 650 430 890 910
Passo 3: 60 85 170 500 275 515 430 650 890 910
Passo 4: 60 85 170 275 500 430 515 650 890 910
Passo 5: 60 85 170 275 430 500 515 650 890 910
Passo 6: nenhuma troca
 Capitulo IV
ORDENAÇÃO
3.2 Método de troca e Partição (quic sort)
É o mais rápido entre os métodos apresentados até o momento, e também o mais utilizado.Esse
método foi proposto por C. A. R. Hoare em 1962 e parte do princímpio que é mais rápido classificar dois
vectores com n/2 elementos cada um, do que um com n elementos (dividir um problema maior em dois
menores).

A parte maisdelicada do método é o particionamento do vector. O vector é particionado em tês

segmentos:

V[1],.....,V[i - 1] V[i] V[i + 1],.....,V[n]

( segmento 1) ( segmento 2) ( segmento 3)
A partição é realizada através de escolha arbitrária de elementos menor ou igual a M (um número
pré-estabelecido), aplica-se um método simplis de ordenação.

o algorítmo do quick sort é o seguinte:

-Escolher arbitrariamente um elemento do vector (normalmente o meio) e colocá-lo em uma variável

auxiliar X;
- Inicializar dois ponteiros I e J (I=1 e J=n);
- Percorrer o vector a partir da direita até que se encontre um V[I] ≥ X (incrementando o valor de I)
- Percorrer o vector a partir da direita até que se encontre um V[I] ≤ X (decrementando o valor de J);
-Trocar os elementos V[I] e V[J] (estão forado lugar) efazer I =I +1 e J =J – 1;
- Continuar esses processos até que I e J se cruzem em algum ponto do vector;
- Após obtidos os dois elementos do vector através do processo de parição, cada um é ordenado
recursivamnte
 Capitulo IV
ORDENAÇÃO
3.2 Método de troca e Partição (quic sort)
Algoritmo:
Procedimento Quicksort (esq, dir: inteiro)
Início
Var Até que i > j
X, i, j, aux :inteiro; Se esq < j Então
i = esq Quicksort (esq, j)
j = dir Fim-se
x = v[ (i + j) Div 2] Se dir > i Então
Repita Quicksort (i, dir)
Enquanto x > v [i] faça (x < v(j)) Fim-se
i = i +1 (crescente) Fim.
Fim-Enquanto

Enquanto x < v [j] faça (x > v(j))

j=j-1 (decrescente)
Fim-enquanto
Se i <= j Então
aux = v[i]
v [i] = v [j]
v [j] = aux
i=i+1
J=J–1
Fim-se
 Capitulo IV
ORDENAÇÃO
4. Ordenação por selecção

Nessa abordagem, é realizada uma selcção sucessiva do menor (ou maior) valor
contido no vector. A cada passo este menor (maior) valor é colocado na sua
posição correcta. Repete-se o processo para o segmento que contém os elementos
não seleccionados.

4.1 Selecção Directa

• A cada passo encontra-se o menor elemento dentro do segmento com os

elementosnão seleccionados;
•Troca-se este elemento com o primeiro elemento do segmento
•Actualiza-se o tamanho do segmento (menos um elemento);
•Este processo é repetido até que o segmento fique com apenas um elento.
 Capitulo IV
ORDENAÇÃO

Exemplo:

19 25 10 18 35 17 15 13 TAM = 8
10 25 19 18 35 17 15 13 TAM = 7
10 13 19 18 35 17 15 25 TAM = 6
10 13 15 18 35 17 19 25 TAM = 5
10 13 15 17 35 18 19 25 TAM = 4
10 13 15 17 18 35 19 25 TAM = 3
10 13 15 17 18 19 35 25 TAM = 2
10 13 15 17 18 19 25 35 TAM = 1
 Capitulo IV
ORDENAÇÃO
Algorítimo:
Const:
TAM = 15
Tipos
V = vector [1..TAM] de inteiros
Var
Vet: v
I, j, temp, pos_menor : inteiro
Início
Para i = 1 até TAM faça
Leia ( vet [i] )
Fim-para
Para i = 1 até TAM - 1 faça
Pos_menor = i
Para j = i + 1 até TAM faça
Se vet [j] < vet [pos_menor] Então
Pos_menor = j
Fim-se
Fim-para
Temp = vet [i]
Vet [i] = vet [pos_menor]
Vet [pos_menor] = temp
Fim-para
Fim
 Capitulo IV
ORDENAÇÃO
4.2. Selecção em Árvore (Heap Sort)
Utiliza uma estrutura de árvore binária para a ordenação. A ordenação é realizada em
duas fases:
1 ª Fase:
- Monta-se uma árvore binária (heap) contendo todos os elemento do vector de forma
que o valor contido em qualquer modo seja maior do que os valores de seus
sucessores. A árvore binária é estruturada no próprio vector da seguinte forma:
a) Sucessor á esquerda de i: 2i (se 2i < a)
b) Sucessor á direita de i: 2i + 1 (se 2i + 1 < n)

- Trasnsformação da árvore num heap: é realizada do menor nivel até a raiz,

trocando-se cada nodo com maior de seus sucessores imediatos. Repete-se este
processo até cada nodo ser maior que seus sucessores imediatos.
 Capitulo IV
ORDENAÇÃO
4.2. Selecção em Árvore (Heap Sort)
Utiliza uma estrutura de árvore binária para a ordenação. A ordenação é realizada em
duas fases:
2ª Fase:
- Após a formação do heap segue-se a fase de classificação propriamente dita, na
qual o valor que está na raiz da árvore (maior valor contido na árvore) é colocado
na sua posição correcta, trocando-o com o elemento de maior índice de árvore (a
árvore fica com 1 elemento a menos).

Este novo elemento colocado na raiz pode violar a propriedade do heap, de modo
que deve-se restaurar o heap novamente. Este procedimento é repetido até que
a árvore fique com um unico elemento.
Exercício 6
(1,7)
56 30 1 38 90 11 95
Esq. = 1...... I=1
Dir =7.........J =7 Y= Vet [ (I+j) Div 2] = Vet [ (1+7) Div 2] = Vet [4] = 38
Trocal 1: I=2, J=7 56 95 1 38 90 11 30
I=3 J=6 {após a troca o incrimenta e o J discrimenta uma unidade}
Troca 2: I=3, J=5
56 95 90 38 1 11 30
I=4 J=4
Troca 3: I=4, J=4 56 95 90 38 1 11 30
I=5 J=3 {Houve troca sem nenhum efeito visivel}
O ‘I’ já é Superior a ‘J’ por isso fazemos um novo chamamento
ESQUERDA DIREITA
Esq < J? Dir > i ?
A1 <3 True B 7>5 True {Fica para depois de tartar toda a parte esquerda}
A (1,3)
Esq. = 1...... I=1
Dir =3.........J =3 Y= Vet [2]=95
Troca 4: I=1, J=2 95 56 90 38 1 11 30
I=2 J=1
O I já é Superior a J por isso fazemos um novo chamamento
ESQUERDA DIREITA
Esq < J? Dir > i ?
C1 <1 False Fim e vai a direita D 3>2 True {resolve-se agora porque a esquerda é falso}
D (2,3)
Esq. = 2...... I=2
Dir =3.........J =3 Y= Vet [3]=90
Troca 5: I=2, J=3 95 90 56 38 1 11 30
I=3 J=2
O I já é Superior a J por isso fazemos um novo chamamento
ESQUERDA DIREITA
Esq < J ? Dir > I ?
E2 <1 False Fim e Vai a direita F3>2 False {Voltamos para traz B o ultimo que deixamos para depois}
B (5,7)
Esq. = 5...... I=5
Dir =7.........7=3 Y= Vet [6]=11
Troca 6: I=5, J=7 95 90 56 38 1 11 30
I=6 J=6