(Grafos) - Unisinos

Estruturas Avançadas de Dados II 

(Grafos) 

Patricia Jaques 

Adaptado de Professor Gilberto Irajá Müller 

Última atualização 18/04/2013

Introdução 

! Porque estudar Grafos 

! Importante ferramenta matemática com aplicação em diversas 

áreas do conhecimento 

! Genética, química, pesquisa operacional, telecomunicações, 

engenharia elétrica, redes de computadores, conexão de vôos 

aéreos, restrições de precedência, fluxo de programas, dentre 

outros 

! Utilizados na definição e/ou resolução de problemas

Grafo 

! Conjunto de Vértices e uma coleção de Arestas 

conectando pares de vértices

Grafo: informalmente 

Um grafo é uma forma de representar 

relações entre pares de objetos

Exemplo 

! Vértices: códigos de aeroportos 

! Arestas: rotas aéreas e distâncias

Introdução 

! O rio Pregel divide o centro da cidade de 

Königsberg (Prússia no século XVII, atual 

Kaliningrado, Rússia) em quatro regiões. 

! Atravessar todas as pontes, voltando ao 

lugar de saída, sem repetir alguma

Introdução 

! As pontes de Königsberg 

! Resolvido em 1736 por Leonhard Euler 

! Euler provou que não existia caminho 

que possibilitasse tais restrições 

! Necessário um modelo para representar o 

problema 

! Abstração de detalhes irrelevantes: 

! Área de cada ilha 

! Formato de cada ilha 

! Tipo da ponte, etc.

Introdução 

! As pontes de Königsberg 

! Euler generalizou o problema 

através de um modelo de 

grafos; 

! Euler mostrou que não existe 

o trajeto proposto utilizando o 

modelo em grafos. 

! Talvez esse seja o 

primeiro modelo de 

grafos.

Introdução 

! O problema das 3 casas 

! É possível conectar os 3 serviços às 3 casas sem 

haver cruzamento de tubulação? 

água luz telefone

Introdução 

! Quantas cores são 

necessárias para 

colorir o mapa do 

Brasil, sendo que 

estados adjacentes 

não podem ter a 

mesma cor?

Introdução 

! Questões sobre o caminho mínimo 

De forma a reduzir seus custos operacionais, uma empresa de transporte 

de cargas deseja oferecer aos motoristas de sua frota um mecanismo que 

os auxilie a selecionar o melhor caminho (o de menor distância) entre 

quaisquer duas cidades por ela servidas, de forma a que sejam 

minimizados os custos de transporte.

Introdução 

! Questões sobre o caminho mínimo

Modelagem de Grafos 

! Estamos interessados em objetos e 

nas relações entre eles 

! Quem são eles nos problemas 

apresentados? 

! Como representar graficamente?

Introdução 

• No problema das casas 

• Vértices são casas e serviços 

• Arestas são as tubulações entre casas e serviços 

! O problema das 3 casas 

! É possível conectar os 3 serviços às 3 casas sem 

haver cruzamento de tubulação? 

A teoria 

dos grafos 

mostra que 

não é 

possível! 

água luz telefone

Introdução 

• No problema da coloração de mapas 

• Vértices são estados 

• Arestas relacionam estados vizinhos 

• 4 cores são necessárias para colorir qualquer 

mapa

Introdução 

! Questões sobre o caminho mínimo 

De forma a reduzir seus custos operacionais, uma empresa de 

transporte de cargas deseja oferecer aos motoristas de sua frota um 

mecanismo que os auxilie a selecionar o melhor caminho (o de menor 

distância) entre quaisquer duas cidades por ela servidas, de forma a que 

sejam minimizados os custos de transporte. 

• No problema do caminho 

mais curto 

• Vértices são as cidades 

• Arestas são as ligações entre 

as cidades


! Três desenvolvimentos isolados despertaram o interesse 

pela área 

! Formulação do problema das 4 cores 

(De Morgan 1852). 

! Qual a quantidade mínima de cores para colorir um mapa de tal 

forma que países fronteiriços possuam cores diferentes? 

! Apresenta-se um exemplo em que 3 cores não são suficientes. 

! Uma prova de que 5 cores é suficiente foi formulada. 

! Conjecturou-se então que 4 cores seriam suficientes. 

! Esta questão ficou em aberto até 1976 quando Appel e Haken 

provaram para 4 cores


! Três desenvolvimentos isolados despertaram o 

interesse pela área 

! Problema do ciclo Hamiltoniano (Hamilton 1859) 

! Um caminho hamiltoniano é um caminho que permite passar 

por todos os vértices de um grafo, sem repetição (uma única 

vez). 

Problema do caixeiro viajante 

Existem n cidades. Cada par de cidades pode ser adjacente 

ou não arbitrariamente. Partindo de uma cidade qualquer, o 

problema consiste em determinar um trajeto que passe 

exatamente uma vez em cada cidade e retorne ao ponto de 

partida.


! Três desenvolvimentos isolados despertaram o 

interesse pela área 

! Teoria das árvores 

- Em 1847 Kirchhoff propôs a teoria 

de árvores (subconjunto da teoria de 

grafos) para resolver problemas de 

circuitos elétricos.

Conceitos e Características

Conceitos e Características 

! Dois tipos de elementos 

! Vértices ou nós ou nodos 

! Arestas ou caminho ou arco 

v1 

v3 

v4 

v2 

v5 

v6


! Grafo 

! G = (V, E) 

! V é um conjunto finito não-vazio de vértices 

! E é um conjunto de pares não ordenados de 

elementos distintos de V, chamados de arestas 

! Cada aresta e pertencente ao conjunto E será 

denotada pelo par de vértices (x,y) que a forma


! Grafo

Tipos de arestas 

! Arestas orientadas (arestas dirigidas) 

! Pares de vértices ordenados 

! Origem e Destino 

! Arestas não-orientadas (não dirigidas) 

! Não há ordem dos vértices

Tipos de grafos 

! Grafo orientado (ou dígrafo) 

! Todas as arestas são orientadas 

! Grafo não orientado 

! Não há arestas orientadas

Tipos de grafos 

! Grafo ponderado 

! arestas possuem um 

rótulo numérico que 

indica seu peso. 

! Peso = medida genérica 

! Grafo rotulado 

(em vértices ou arestas) 

! Quando os vértices ou arestas 

possuem rótulos

Tipos de arestas: contextos reais 

Não orientado 

Vértices 

Cidades 

Autores 

Arestas 

Estradas 

Co-autoria 

Computadores Conexões de 

rede 

Orientado 

Vértices 

Cidades 

Disciplinas 

Página web 

Arestas 

Vôos 

Pré-requisitos 

Links 

Ponderado (arestas possuem pesos) 

Vértices Arestas - 

Peso 

Cidades Estradas - 

Distância

Exercício 

! O grafo das palavras é definido assim: 

! cada vértice é uma palavra da língua portuguesa e 

! duas palavras são adjacentes se diferem em exatamente uma posição. 

! Por exemplo, rato e ralo são adjacentes, enquanto ralo e rota não são. 

! Faça um grafo definido pelas palavras abaixo: 

! Palavras: ralo ramo rata rato remo reta reto rota

Terminologia 

! Vértices finais 

! U e V são vértices finais de a 

! Arestas incidentes 

! a, d e b incidem em V 

! Vértices adjacentes 

! U e V são adjacentes 

! Grau de um vértice 

! X tem grau 5 (nro de arestas incidentes) 

! Grafos orientados 

! Grau de entrada 

! Grau de saída 

! Arestas paralelas 

! h e i (mesmos vértices finais) 

! Laço 

! j (único vértice final)

Terminologia 

! Grafo simples 

! Não possui: 

! Arestas paralelas 

X 

h 

i 

Z 

j 

! h e i 

! Laços 

! j 

X 

h 

i 

Z 

j

Terminologia 

! Subgrafo de um Grafo G 

! É um outro grafo H cujos vértices e arestas são 

subconjuntos dos vértices e arestas de G. 

31


! Grafo simples 

v1 

v3 

V = {v1, v2, v3, v4, v5, v6} 

v4 

e1 

v5 

v2 

v6 

E = {{v1,v2},{v1,v3},{v1,v4},{v2,v4},{v3,v4},{v4,v5}} 

e1 é incidente a v4 e v5

Exercício 

! Desenhe o grafo simples a seguir: 

! V = {1,2,3,4,5,6}; 

! E ={(1,2),(1,3),(3,2),(3,6),(5,3),(5,1),(5,6),(4,6), (4,5),(6,1), 

(6,2),(3,4)}

Terminologia 

! Caminho 

! Seqüência alternada de vértices e arestas 

! Se for um grafo simples: é possível representar como uma 

sequencia de vértices 

! Inicia e termina em um vértice 

! Cada aresta é precedida e seguida por seus pontos finais 

! Caminho simples 

! Vértices e arestas distintos 

! Exemplo 

! P1 = (V,b,X,h,Z) 

! Contra-exemplo 

! P2 = (U,c,W,e,X,g,Y,f,W,d,V)

Exercício 

! A partir do grafo dirigido abaixo: 

a) Quais são os vértices adjacentes ao vértice 3? 

b) Qual o caminho mais curto do nó 3 para o nó 6? 

c) Qual o caminho de comprimento 8 do nó 1 para o nó 6?

Terminologia 

! Ciclo 

! Caminho em que os vértices de início e fim são 

os mesmos 

! laço: ciclo de tamanho 1 

! Ciclo simples 

! Vértices e arestas distintos, exceto o primeiro 

e o último 

! Exemplo 

! C1 = (V,b,X,g,Y,f,W,c,U,a,↵) 

! Contra-exemplo 

! C2 = (U,c,W,e,X,g,Y,f,W,d,V,a, ↵)

Grafo Conexo 

! Grafo não dirigido 

! Um grafo não dirigido é conexo se existir um caminho 

entre quaisquer dois vértices do grafo. 

37

Grafo dirigido 

! Grafo fortemente conexo 

! No caso de grafos orientados (dígrafos), um grafo é 

fortemente conexo se existe um caminho de a para b 

e de b para a, para cada par a,b de vértices do grafo. 

38

Grafo dirigido 

! Grafo fracamente conexo 

! Um dígrafo é dito fracamente conexo se, ao 

substituirmos os arcos (setas) por arestas (retas), 

temos um grafo não-dirigido conexo. 

! Esse grafo não-dirigido gerado é chamado de “grafo não 

orientado subjacente”. 

39

Terminologia 

! Floresta 

! Grafo acíclico (sem ciclos) 

! Árvore 

! Grafo conexo e acíclico 

! ou Floresta conexa

Terminologia 

! Grafo Acíclico 

! grafo que não contém um ciclo 

! Evitar usar a expressão "o grafo é cíclico" 

no lugar de "o grafo não é acíclico” 

! para não confundir com grafo cíclico (ou 

grafo ciclo => grafo regular de grau 2) 

! Grafo Acíclico Orientado (GAOS) 

! directed acyclic graph (DAG) 

! grafo orientado que não possui ciclo

Propriedades 

! Propriedade 1 

Σ v deg(v) = 2m 

! Cada ponto final é contado 

duas vezes 

! Propriedade 2 

! Para um grafo simples não 

orientado 

m ≤ n(n-1)/2 

! Cada vértice tem grau máximo 

de (n-1) 

Notação 

n número de vértices 

m número de arestas 

deg(v) grau do vértice v 

Exemplo 

n = 4 

m = 6 

deg(v) = 3 

v

Exercício 

a) o grafo é simples? 

b) o grafo é conexo? 

c) é possível encontrar dois caminhos entre 3 e 6? 

d) é possível encontrar um ciclo? 

e) é possível encontrar uma aresta cuja remoção transforma o grafo em um 

grafo acíclico? 

f) é possível encontrar uma aresta cuja remoção transforma o grafo em 

desconexo?

Implementação 

Estruturas de dado para Grafos


! Representação de Grafos por Computador 

Embora seja conveniente a representação de 

grafos através de diagramas de pontos ligados 

por linhas, tal representação é inadequada se 

desejamos armazenar grandes grafos em um 

computador

Como representar?

Complexidade das Operações para Lista de 

Arestas 

Operação 

vertices 

edges 

incidentEdges(v) 

opposite(v, e) 

endVertices(e) 

Descrição 

retorna todos os vértices do grafo 

retorna todos as arestas do grafo 

retorna as arestas incidentes no vértice v 

retorna vértice adjacente ao vértice v pela aresta 

e 

retorna vértices finais da aresta e 

n = número de vértices 

m = número de arestas

TAD Grafo: Estruturas de dados usuais 

! Matriz de adjacência 

! Lista de arestas 

! Lista de adjacência

Matriz de adjacência 

! Através de uma matriz, permite determinar 

vértices adjacentes 

! Espaço: n 2

Matriz de adjacência 

! Para dígrafo

Matriz de Adjacência (versão simples) 

public class GrafoMatriz { 

private boolean matriz[][]; 

private int tam; 

public GrafoMatriz(int tam) { 

this.tam = tam; 

matriz = new boolean[tam][tam]; 

} 

public void addAresta(int i, int j) { 

if (i >= 0 && i < tam && j >= 0 && j < tam) { 

matriz[i][j] = true; 

matriz[j][i] = true; 

} 

} 

(C) Christopher Rosa Pohlmann 51

Matriz de Adjacência (versão simples) 

continuação 

public void removeAresta(int i, int j) { 

if (i >= 0 && i < tam && j >= 0 && j < tam) { 

matriz[i][j] = false; 

matriz[j][i] = false; 

} 

} 

public boolean isAresta(int i, int j) { 

if (i >= 0 && i < tam && j >= 0 && j < tam) 

return matriz[i][j]; 

else 

return false; 

} 

} 


TAD Matriz de adjacência 

! Matriz de referências para 

objetos aresta. Índices da 

matriz associam o vértice i ao 

vértice j

Matriz de Adjacência 

u 

a 

v 

b 

w 

0 u 1 v 2 w 

a 

0 1 2 

0 ∅ ∅ 

1 ∅ 

2 ∅ ∅ 

b 

54

class Vertice { 

private T dados; 

public Vertice(T d) { 

this.dados = d; 

} 

public T getDados() { 

return this.dados; 

} 

public void setDados(T d) { 

this.dados = d; 

} 

public String toString() { 

return this.dados.toString(); 

} 

public boolean equals(Object obj) { 

if (obj==null) return false; 

else if (obj instanceof Vertice) { 

T dadosObj = ((Vertice) obj).getDados(); 

return dados.equals(dadosObj); 

} 

else return false; 

} 

} 


public class Aresta { 

private A dados; 

private Vertice v1, v2; 

public Aresta(A dados, Vertice v1, Vertice v2) { 

this.dados = dados; 

this.v1 = v1; 

this.v2 = v2; 

} 

public A getDados() { 

return dados; 

} 

public void setDados(A dados) { 

this.dados = dados; 

} 

public Vertice getV1() { 

return v1; 

} 

public void setV1(Vertice v1) { 

this.v1 = v1; 

} 

public Vertice getV2() { 

return v2; 

} 

public void setV2(Vertice v2) { 

this.v2 = v2; 

} 

public String toString() { 

return "[" + v1 + ", " + v2 + "]"; 

} 

56

public class GrafoMatriz { 

private ArrayList arestas; // lista de arestas do grafo 

private ArrayList vertices; // lista de vértices do grafo 

private Aresta matriz[][]; // matriz de adjacência: linhas e colunas representam vértices 

// células representam arestas existentes entre os respectivos vértices 

// Construtor. Apenas inicializa as estruturas de dados 

public GrafoMatriz(int n) { 

this.arestas = new ArrayList(); 

this.vertices = new ArrayList(); 

this.matriz = (Aresta[][]) Array.newInstance(Aresta.class, n, n);; 

} 

// Insere um novo vértice com dado 'v' 

public void addVertice(V v) throws ArrayIndexOutOfBoundsException { 

// se matriz já está completamente ocupada, gera exceção 

if (matriz.length==vertices.size()) throw new ArrayIndexOutOfBoundsException(); 

else { 

// cria novo vértice 

Vertice objVertice = new Vertice(v); 

this.vertices.add(objVertice); 

} 

} 

57

Insere uma nova aresta com vértices finais 'v1' e 'v2' e dado 'a' 

public boolean addAresta(V v1, V v2, A a) { 

// obtendo índice da aresta na matriz 

int i = this.vertices.indexOf(new Vertice(v1)); 

int j = this.vertices.indexOf(new Vertice(v2)); 

if (i!=-1 && j!=-1) { // se vértices encontrados (i e j terão as posiçòes dos vértices na lista 

// criando objeto aresta 

Aresta objAresta = new Aresta(a, vertices.get(i), vertices.get(j)); 

// adicionando a aresta a lista de arestas 

this.arestas.add (objAresta); 

// fazendo a matriz referenciar a aresta 

// para arestas não-dirigidas, deve-se setar posição (i,j) e (j,i) 

this.matriz[i][j] = objAresta; 

this.matriz[j][i] = objAresta; 

return true; 

} 

return false; 

} 

58

Remove o vértice 'v'. Retorna true se 'v' foi encontrado e removido, false caso contrário 

public boolean delVertice(V v) { 

int posVertice = this.vertices.indexOf(new Vertice(v)); 

V objVertice = this.vertices.remove(posVertice).getDados(); 

// a fazer 

// importante lembrar que quando um vértice for removido, a matriz tem que ser redimensionada 

// e, por consequencia, as arestas dentro destas 

return (objVertice!=null); 

} 

// Remove a aresta de dado 'a'. Retorna true se 'a' foi encontrada e removida, false caso contrár 

public boolean delAresta(A a) { 

Aresta objAresta = null; 

// deletando aresta da lista de arestas 

int k=0; 

while ( k

Retorna uma lista contendo todos os vértices adjacentes (vizinhos) a um vértice 'v' 

public ArrayList getVizinhos(V v) { 

ArrayList objAresta = new ArrayList(); 

// descobre linha/coluna da matriz que guarda arestas que contém o vértice 'v’ 

// como um vértice incidente 

int posVertice = this.vertices.indexOf(new Vertice(v)); 

// percorre linha da matriz do vértice v 

for (int i = 0; i < this.matriz[posVertice].length; i++) { 

if (this.matriz[posVertice][i] != null) { 

// para cada célula da linha correspondente ao vértice na matriz, 

// verifica se há uma aresta (!=null) 

// se for diferente de null, testa se o dado de v1 é diferente de v, 

// se sim o vértice adjacente está em v1, 

// caso contrário está em v2 

if (matriz[posVertice][i]!=null && !matriz[posVertice][i].getV1().getDados().equals(v)) 

objAresta.add(matriz[posVertice][i].getV1()); 

else if (matriz[posVertice][i]!=null) objAresta.add(matriz[posVertice][i].getV2()); 

} 

} 

return objAresta; 

} 

60

Testa se os vértices 'v1' e 'v2' são adjacentes (vizinhos) 

public boolean isAdjacente(V v1, V v2) { 

int i = this.vertices.indexOf(new Vertice(v1)); 

int j = this.vertices.indexOf(new Vertice(v2)); 

if (i==-1 || j==-1) return false; 

else return this.matriz[i][j] != null; 

} 

61

Complexidade das Operações para 

Matriz de Adjacências 

Operação Tempo Descrição 

vertices O(n) retorna todos os vértices do grafo 

edges O(m) retorna todos as arestas do grafo 

incidentEdges(v) O(n) retorna as arestas incidentes no vértice v 

opposite(v,e) O(1) retorna vértice adjacente ao vértice v pela 

aresta e 

endVertices(e) O(1) retorna vértices finais da aresta e 



Exercício 

Dada a matriz de adjacência ao lado, desenhe o seu respectivo grafo. 



! Representação de Grafos – Lista de Arestas 

Uma maneira simples de armazenar grafos é listando as arestas. 

Cada aresta sabe os seus vértices finais. 

u 

y 

x 

d 

f 

c 

e 

a 

v 

b 

w 

a: (u,v) 

b: (v,w) 

c: (w,x) 

d: (y,x) 

f: (u,y)

TAD Lista de arestas 

! Duas listas: arestas e vértices 

! Acesso direto das arestas para os 

vértices

TAD Lista de arestas 

! Desvantagem 

! Acessar arestas incidentes a um 

vértice requer busca exaustiva de 

arestas

Lista de Arestas 

u 

a 

c 

v 

b 

w 

d 

z 

u v w z 

a 

b c d

Complexidade das Operações para Lista de 

Arestas 

Operação 

Tempo Descrição 



incidentEdges(v) O(m) retorna as arestas incidentes no vértice v 

opposite(v,e) O(1) retorna vértice adjacente ao vértice v pela aresta e 




Lista de adjacência 

! Listas de vértices adjacentes 

! Espaço: n + m 

! Resolve desvantagens da Lista de Arestas

TAD Lista de adjacência 

! Estende a lista de arestas 

provendo acesso dos vértices 

para suas arestas incidentes 

(acesso entre vértices)

Lista de Adjacência 

u 

a 

v 

b 

w 

u v w 

a 

b

class Vertice { 

private T dados; 

private ArrayList listaIncidencia; 

public ArrayList getListaIncidencia() { 

return listaIncidencia; 

} 

public void setListaIncidencia(ArrayList 

listaIncidencia) { 

this.listaIncidencia = listaIncidencia; 

} 


public class GrafoLista { 

private HashMap arestas; // lista de arestas 

private HashMap vertices; // lista de vértices 

public GrafoLista() { 

this.arestas = new HashMap(); 

this.vertices = new HashMap(); 

} 

// Insere um novo vértice com o dado 'v'. 

public void addVertice(V v) { 

// cria novo vértice 

Vertice objVertice = new Vertice(v); 

this.vertices.put(v,objVertice); 

} 


Insere uma nova aresta com vértices finais 'v1' e 'v2' e dado 'a' 

public void addAresta(V v1, V v2, A a) { 

Vertice objVertice1 = this.vertices.get(v1); 

Vertice objVertice2 = this.vertices.get(v2); 

// criando a nova aresta 

Aresta objAresta = new Aresta 

(a, objVertice1, objVertice2); 

// obtendo a lista de incidência dos vértices finais para 

// inserir a nova aresta 

// a nova aresta deve ser inserida na lista de incidência 

// de cada vértice final (v1 e v2) 

ArrayList listaIncidencia = objVertice1 

.getListaIncidencia(); 

listaIncidencia.add(objAresta); 

ArrayList listaIncidencia2 = objVertice2 


listaIncidencia2.add(objAresta); 

// inserindo na lista de arestas 

this.arestas.put(a,objAresta); 

} 


Remove o vértice 'v'. Retorna true se 'v' foi encontrado e removido, false caso contrário 

public boolean delVertice(V v) { 

// removendo vértice da lista de vértices 

Vertice objVertice = this.vertices.get(v); 

if (objVertice!=null) { 

// obtendo a lista de incidência do vértice para deletar suas arestas 

ArrayList listaIncidencia = objVertice 


Object arestasDaLista [] = listaIncidencia.toArray(); 

for (int i = 0; i < arestasDaLista.length; i++) { 

Aresta objAresta = (Aresta)arestasDaLista[i]; 

// chama método delAresta() que deleta a aresta na lista de 

// incidência de seus 2 vértices finais 

delAresta (objAresta); 

} 

this.vertices.remove(v); 

} 

return (objVertice != null); 

} 

// Remove a aresta de dado 'a'. Retorna true se 'a' foi encontrada e removida, 

// false caso contrário 

public boolean delAresta(A a) { 

// obtendo aresta que liga os respectivos vértices 

Aresta objAresta = arestas.get(a); 

if (objAresta!=null) { 

delAresta (objAresta); 

return true; 

} 

return false; 

} 


Remove o objeto Aresta 'objAresta'. 

// Método delAresta é sobrecarregado: pode receber tanto o rótulo da aresta 

// como uma referência para o objeto aresta 

private void delAresta (Aresta objAresta){ 

// obtendo objeto vértice final da aresta 

Vertice vertice = this.vertices.get(objAresta.getV1().getDados()); 

// obtendo a lista de incidencia do vértice para deletar a aresta 

ArrayList listaIncidencia = vertice 


listaIncidencia.remove(objAresta); 

// obtendo outro objeto vértice final da aresta 

vertice = this.vertices.get(objAresta.getV2().getDados()); 

// obtendo a lista de incidencia do vértice para deletar a aresta 

listaIncidencia = vertice 


listaIncidencia.remove(objAresta); 

} 

// deletando a aresta da lista de arestas 

this.arestas.remove(objAresta.getDados()); 


Retorna uma lista contendo todos os vértices adjacentes (vizinhos) a um vértice 'v' 

public ArrayList getVizinhos(V v) { 

ArrayList vizinhos = new ArrayList(); 

// obtendo vértice da lista de vértices 

Vertice objVertice = this.vertices.get(v); 

} 

if (objVertice!=null) { 

// obtendo a lista de incidencia do vértice para obter suas arestas 

// e seus vizinhos 



for (int i = 0; i < listaIncidencia.size(); i++) { 

Aresta objAresta = listaIncidencia.get(i); 

Vertice objV1 = objAresta.getV1(); 


if (objV1.getDados().equals(v)) vizinhos.add(objV2); 

else vizinhos.add(objV1); 

} 

} 

return vizinhos; 


Testa se os vértices 'v1' e 'v2' são adjacentes (vizinhos) 

public boolean isAdjacente(V v1, V v2) { 

// obtendo vértice da lista de vértices 

Vertice objVertice = this.vertices.get(v1); 

if (objVertice!=null){ 

// obtendo a lista de incidencia do vértice para obter suas arestas 

// e seus vizinhos 



for (int i = 0; i < listaIncidencia.size(); i++) { 

Aresta objAresta = listaIncidencia.get(i); 



if (v1.equals(objV1.getDados()) && v2.equals(objV2.getDados())) 

return true; 

else if (v1.equals(objV2.getDados()) && v2.equals(objV1.getDados())) 

return true; 

} 

} 

return false; 

} 


Complexidade das Operações para 

Lista de Adjacências 

Operação Tempo Descrição 



incidentEdges(v) O(deg(v)) retorna as arestas incidentes no vértice v 

opposite(v,e) O(1) retorna vértice adjacente ao vértice v pela aresta e 




TADs Grafo: Resumo 

! Lista de arestas 

! Acesso direto das arestas para os 

vértices incididos (apenas) 

! Lista de adjacência 

! Estende a lista de arestas provendo 

acesso dos vértices para suas 

arestas incidentes (acesso entre 

vértices) 


! Estende a lista de arestas provendo 

adjacências entre vértices em uma 

matriz 

arestas 

vértices 

arestas 

vértices

TADs Grafo: Complexidade de tempo

Qual representação usar? 


! Ok se grafo for denso 

! Lista de Adjacências 

! Melhor representação para grafos esparsos 

! Grafos Densos 

! o número de arestas é próximo de n 2 , ou seja, existe 

quase uma ligação entre cada 2 vértices 

! Grafos Esparsos 

! número de arestas muito menor que n 2 

82

Exercício 

! A complexidade da operação incidentEdges(v) 

(que retorna as arestas incidentes no vértice v) 

em um grafo representado por Matriz de 

Adjacência é O(n). Em um grafo representado 

por Lista de Adjacência é O(deg(v)). Explique 

por que isso acontece. 


Bibliografia 

! Silberchatz, A; Korth, H. F., Sudarshan, S. Sistema de Banco de 

Dados. 3ª. Edição, Makron Books, 1999. 

! Lafore, Robert. Estruturas de Dados & Algoritmos em Java. 

Editora Ciência Moderna, 2004. 

! Thomas H. Cormen - Algoritmos: Teoria e Prática 

! Michael T. Goodrich - Projeto De Algoritmos

(Grafos) - Unisinos

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?