UNIVERSIDADE REGIONAL DE BLUMENAU

DEPARTAMENTO DE SISTEMAS E COMPUTAO

DISCIPLINA PROFESSOR

: ESTRUTURA DE DADOS I : ROBERTO HEINZLE, MSc

CARGA HORRIA : 72 HORAS/AULA

1. OBJETIVO DA DISCIPLINA O objetivo da disciplina de estrutura de dados estudar as principais tcnicas de representao e manipulao de dados.

2. EMENTA Listas lineares rvores Grafos Pesquisa em tabelas:

Classificao de dados:

sequencial binria em rvore por clculo de endereo insero partio e troca seleo intercalao distribuio

3. BIBLIOGRAFIA

Horowitz. Estruturas de Dados, Campus, So Paulo. Knut. The Art of Computer Programming. Vols. I,II e III Veloso, Paulo. Estruturas de Dados, Campus, So Paulo. Szwarcfiter, Jaime Luiz. Estruturas de Dados e Seus Algoritmos. Ltc Editora. Rabuske, Marcia A. Introduo Teoria dos Grafos. Ed. da UFSC, Florianpolis

4. SISTEMA DE AVALIAO (proposta) trs avaliaes individuais em sala (peso 8) cinco programas desenvolvidos em duplas e defendidos individualmente (peso 2) uma avaliao (N-1) para os alunos que perderam uma das avaliaes regulares

LISTAS LINEARES

LISTA LINEAR A ESTRUTURA QUE PERMITE REPRESENTAR UM CONJUNTO DE DADOS AFINS DE FORMA A PRESERVAR A RELAO DE ORDEM LINEAR DE SEUS ELEMENTOS.

DEFINE-SE LISTA LINEAR COMO SENDO O CONJUNTO DE n 0 NS X1, X2, ....., Xn, ORGANIZADOS ESTRUTURALMENTE DE FORMA A REFLETIR AS POSIES RELATIVAS DOS MESMOS: SE n > 0, ENTO X1 O PRIMEIRO N; PARA 1 < k < n, O N Xk PRECEDIDO PELO N Xk-1 E SEGUIDO DO Xk+1; E Xn O LTIMO N. QUANDO n = 0 DIZ-SE QUE A LISTA VAZIA.

EXEMPLOS: PESSOAS ESPERANDO NIBUS LETRAS DE UMA PALAVRA PALAVRAS DE UMA FRASE

LISTAS - DISCIPLINA DE ACESSO

OS DOIS CRITRIOS MAIS USUAIS SO:

1) LIFO (LAST IN FIRST OUT) - O LTIMO ELEMENTO QUE ENTROU O PRIMEIRO A SAIR. ESTRUTURAS LINEARES COM ESTA DISCIPLINA DE ACESSO SO DENOMINADAS PILHAS.

2) FIFO (FIRST IN FIRST OUT) O PRIMEIRO ELEMENTO QUE ENTROU O PRIMEIRO A SAIR. ESTRUTURAS LINEARES COM ESTA DISCIPLINA DE ACESSO SO DENOMINADAS FILAS.

LISTAS - IMPLEMENTAO

ALOCAO SEQUENCIAL OU CONTGUA

A MANEIRA MAIS SIMPLES DE ACOMODAR UMA LISTA LINEAR EM COMPUTADOR ATRAVS DA UTILIZAO DE UM VETOR. A REPRESENTAO POR VETOR EXPLORA A SEQENCIALIDADE DA MEMRIA DE TAL FORMA QUE OS NS DE UMA LISTA SEJAM ARMAZENADOS EM ENDEREOS CONTGUOS, OU IGUALMENTE DISTANCIADOS UM DO OUTRO.

X1 X2 X3 X4 X5 X6

Xn-1 Xn

LISTAS - IMPLEMENTAO
EXEMPLOS DE ALGORITMOS PARA AS OPERAES DE INSERO E RETIRADA DE UM ELEMENTO NUMA PILHA COM ALOCAO CONTGUA: VARIVEIS: TOPO (NDICE QUE INDICA A LTIMA POSIO OCUPADA) MXIMO (VARIVEL CUJO VALOR REPRESENTA O TAMANHO DO VETOR) VALOR (ELEMENTO INCLUDO/RETIRADO) INICIO INSERIR SE TOPO = MAXIMO ENTO OVERFLOW SENO TOPO := TOPO + 1 VETOR[TOPO] := VALOR FIM SE FIM

INICIO RETIRAR SE TOPO = 0 ENTO UNDERFLOW SENO VALOR := VETOR[TOPO] TOPO := TOPO - 1 FIM SE FIM

LISTAS - IMPLEMENTAO

EXEMPLO DE ALGORITMO PARA A OPERAO DE INSERO DE UM ELEMENTO NUMA FILA COM ALOCAO CONTGUA:

VARIVEIS: COMECO (NDICE QUE INDICA O PRIMEIRO ELEMENTO DA FILA INICIALIZADA C/ 0) FINAL (NDICE QUE INDICA O LTIMO ELEMENTO DA FILA - INICIALIZADA C/ 0) MXIMO (VARIVEL CUJO VALOR REPRESENTA O TAMANHO DO VETOR) VALOR (ELEMENTO A SER INCLUDO) PROV (UMA VARIVEL PROVISRIA)

INICIO INSERIR PROV := (FINAL MOD MAXIMO) + 1 SE PROV COMECO ENTO FINAL := PROV VETOR[FINAL] := VALOR SE COMECO = 0 ENTO COMECO := 1 FIM SE SENO OVERFLOW FIM SE FIM

LISTAS - IMPLEMENTAO

EXEMPLO DE ALGORITMO PARA A OPERAO DE RETIRADA DE UM ELEMENTO NUMA FILA COM ALOCAO CONTGUA: VARIVEIS: COMECO (NDICE QUE INDICA O PRIMEIRO ELEMENTO DA FILA INICIALIZADA C/ 0) FINAL (NDICE QUE INDICA O LTIMO ELEMENTO DA FILA - INICIALIZADA C/ 0) MXIMO (VARIVEL CUJO VALOR REPRESENTA O TAMANHO DO VETOR) VALOR (ELEMENTO EXCLUDO)

INICIO RETIRAR SE COMECO 0 ENTO VALOR := VETOR[COMECO] SE COMECO = FINAL ENTO COMECO := 0 FINAL := 0 SENO COMECO := (COMECO MOD MAXIMO) + 1 FIM SE SENO UNDERFLOW FIM SE FIM

LISTA ENCADEADA - ALOCAO DINMICA

PILHA

CADA NODO POSSUI, NO MNIMO, UM APONTADOR PARA O SEU ANTECESSOR TEM-SE UM APONTADOR PARA O TOPO DA PILHA

TOPO

dado

dado

dado

PILHA - ALOCAO DINMICA IMPLEMENTAO

PROGRAM PILHA ; USES CRT ; TYPE APONT = ^NODO ; NODO = RECORD MATRIC : INTEGER ; PESO : REAL ; ALTURA : REAL ; SEGUINTE : APONT ; END ; VAR TOPO : APONT ;
FUNCTION POE_PILHA (M: INTEGER; P,A: REAL): APONT;

VAR ALOCA : APONT ; BEGIN NEW(ALOCA) ; POE_PILHA := ALOCA ; ALOCA^.MATRIC := M ; ALOCA^.PESO := P ; ALOCA^.ALTURA := A ; ALOCA^.SEGUINTE := TOPO ; TOPO := ALOCA ; END ;

PILHA - ALOCAO DINMICA IMPLEMENTAO

FUNCTION TIRA_PILHA : INTEGER ; VAR LIBERADO : APONT ; BEGIN IF (TOPO = NIL) THEN TIRA_PILHA := 0 ELSE BEGIN TIRA_PILHA := TOPO^.MATRIC ; LIBERADO := TOPO ; TOPO := TOPO^.SEGUINTE ; DISPOSE(LIBERADO) ; END ; END ;

PILHA - ALOCAO DINMICA IMPLEMENTAO

VAR MATRICULA,RET : INTEGER; PESO,ALTURA : REAL; A : CHAR; BEGIN TOPO := NIL; CLRSCR; WRITE('INFORME O NUMERO DA MATRICULA: '); READLN(MATRICULA); WHILE (MATRICULA <> 99) DO BEGIN IF (MATRICULA = 0) THEN BEGIN RET := TIRA_PILHA; IF (RET = 0) THEN WRITELN('** LISTA VAZIA - IMPOSSIVEL RETIRAR **') ELSE WRITELN('RETIRADO MATRICULA = ',RET); END ELSE BEGIN WRITE('INFORME O PESO: '); READLN(PESO); WRITE('INFORME A ALTURA: '); READLN(ALTURA); IF (POE_PILHA(MATRICULA,PESO,ALTURA) <> NIL) THEN WRITELN('INCLUIDO ELEMENTO: ',MATRICULA) ELSE WRITELN('** ERRO - INCLUSAO NAO EFETUADA **'); END; A := READKEY; CLRSCR; WRITE('INFORME O NUMERO DA MATRICULA: '); READLN(MATRICULA); END; WHILE (TIRA_PILHA <> 0) DO; END.

PILHA - ALOCAO DINMICA IMPLEMENTAO

#include <stdio.h> #include <stdlib.h> #include <alloc.h> #include <string.h> struct elo* coloca (int,char*) ; int retira(); struct elo {int matric; char fone[20]; struct elo *anterior; } *no, *comeco ; void main() { char telefone[20] ; int matricula,morreu ; struct elo *voltou ; comeco = NULL ; printf("\n\n\ainforme o numero da matricula: ") ; scanf("%d",&matricula) ; while(matricula != 99) { if (matricula) { printf("informe o telefone: ") ; scanf("%s",telefone) ; if (voltou = coloca(matricula,telefone)) printf("incluido a matricula %d no endereco %p", matricula,voltou) ; else printf("problemas na alocacao - elemento nao incluido") ; } else if (morreu = retira()) printf("\nfoi retirada a matricula numero %d",morreu) ; else printf("\na lista esta vazia - impossivel retirar") ; printf("\n\n\ainforme o numero da matricula: ") ; scanf("%d",&matricula) ; } while(retira()) ; }

PILHA - ALOCAO DINMICA IMPLEMENTAO

int retira() { struct elo *aux; int eliminado = 0; if (comeco) { eliminado = (*comeco).matric ; aux = (*comeco).anterior ; free(comeco) ; comeco = aux ; } return(eliminado) ; } struct elo *coloca(int num,char *telef) { no = (struct elo*) malloc(sizeof(struct elo)); if (no) { (*no).matric = num ; strcpy((*no).fone,telef); (*no).anterior = comeco ; comeco = no ; } return no ; }

LISTA ENCADEADA - ALOCAO DINMICA FILA

CADA NODO POSSUI, NO MNIMO, UM APONTADOR PARA O SEU SUCESSOR TEM-SE UM APONTADOR PARA CADA EXTREMIDADE DA FILA

COMECO

FINAL

dado

dado

dado

FILA - ALOCAO DINMICA IMPLEMENTAO

PROGRAM FILA ; USES CRT ; TYPE APONTADOR = ^LISTA ; LISTA = RECORD MATRIC,IDADE : INTEGER ; PROXIMO : APONTADOR ; END ; VAR PRIMEIRO, ULTIMO : APONTADOR ; FUNCTION INSERE(MT,ID : INTEGER) : APONTADOR ; VAR PTAUX : APONTADOR ; BEGIN NEW(PTAUX) ; INSERE := PTAUX ; PTAUX^.MATRIC := MT ; PTAUX^.IDADE := ID ; PTAUX^.PROXIMO := NIL ; IF (PRIMEIRO <> NIL) THEN ULTIMO^.PROXIMO := PTAUX ELSE PRIMEIRO := PTAUX ; ULTIMO := PTAUX ; END ;

FILA - ALOCAO DINMICA IMPLEMENTAO

FUNCTION RETIRA : INTEGER ; VAR PTAUX : APONTADOR ; BEGIN RETIRA := 0 ; IF (PRIMEIRO <> NIL) THEN BEGIN PTAUX := PRIMEIRO ; RETIRA := PRIMEIRO^.MATRIC ; PRIMEIRO := PRIMEIRO^.PROXIMO ; DISPOSE(PTAUX) ; IF (PRIMEIRO = NIL) THEN ULTIMO := NIL ; END ; END ;

FILA - ALOCAO DINMICA IMPLEMENTAO

VAR M,I : INTEGER ; PTAUX : APONTADOR ; BEGIN PRIMEIRO := NIL ; ULTIMO := NIL ;

CLRSCR ; WRITE('INFORME A MATRICULA: '); READ(M) ; WHILE (M <> 99) DO BEGIN IF (M = 0) THEN BEGIN I := RETIRA ; IF (I = 0) THEN WRITELN('LISTA VAZIA - IMPOSSIVEL RETIRAR') ELSE WRITELN('RETIRADA A MATRICULA ',I) ; END ELSE BEGIN WRITE('INFORME A IDADE: ') ; READ(I) ; PTAUX := INSERE(M,I) ; IF (PTAUX = NIL) THEN WRITELN('**ERRO - ELEMENTO NA0 INCLUIDO**') ELSE WRITELN('INCLUSAO EFETUADA COM SUCESSO') ; END ; WRITELN ; WRITE('INFORME A MATRICULA: '); READ(M) ; END ; WHILE (RETIRA <> 0) DO ; END .

RVORES

UMA RVORE A UM CONJUNTO FINITO DE n NODOS, TAL QUE SE n > 0, ENTO

1. EXISTE UM NODO ESPECIAL, CHAMADO RAZ DA RVORE; 2. OS RESTANTES n-1 NODOS ESTO PARTICIONADOS EM m CONJUNTOS DISJUNTOS, A1,A2,......,Am , CADA UM DOS QUAIS POR SUA VEZ UM RVORE. ESSAS RVORES SO CHAMADAS SUBRVORES DA RAZ.

DA MESMA FORMA QUE AS LISTAS LINEARES, RVORES SO ESTRUTURAS DE DADOS QUE CARCATERIZAM UMA RELAO ENTRE OS DADOS QUE A COMPEM. NO CASO DE RVORES, A RELAO EXISTENTE ENTRE OS DADOS (DENOMINADOS NS OU NODOS) UMA RELAO DE HIERARQUIA, ONDE UM CONJUNTO DE DADOS HIERARQUICAMENTE SUBORDINADO A OUTRO. RVORES REPRESENTAO GRFICA

A B C

GRAFO

E D B F A G C

A B D E F C G
INDENTAO

DIAGRAMA DE VENN

(A(B(D,E,F),C(G)))
PARNTESES

RVORES - TERMINOLOGIA
PELA DEFINIO DE RVORE, CADA N DA RVORE A RAZ DE UMA SUBRVORE. O NMERO DE SUBRVORES DE UM N O GRAU DAQUELE N. UM N DE GRAU IGUAL A ZERO DENOMINADO FOLHA OU N TERMINAL. A RAZ DA RVORE TEM NVEL ZERO, ENQUANTO O NVEL DOS DEMAIS NS IGUAL AO NMERO DE LINHAS QUE O LIGA A RAZ.

A ALTURA DE UMA RVORE DEFINIDA COMO SENDO O NVEL MAIS ALTO DA RVORE. DENOMINA-SE DE FLORESTA UM CONJUNTO DE ZERO OU MAIS RVORES DISJUNTAS. ASSIM, SE ELIMINARMOS O N RAZ DE UMA RVORE, O QUE DELA RESTAR FORMA UMA FLORESTA. INVERSAMENTE, SE UNIRMOS AS RAZES DAS RVORES QUE FORMAM UMA FLORESTA COM UM N ADICIONAL, FORMAMOS UMA RVORE. QUANDO A ORDEM DAS SUBRVORES SIGNIFICATIVA, DIZEMOS QUE A RVORE ORDENADA. QUANDO A ORDEM NO SIGNIFICATIVA DIZEMOS QUE A RVORE ORIENTADA, UMA VEZ QUE APENAS A ORIENTAO IMPORTANTE.

RVORES BINRIAS

RVORES BINRIAS SO ESTRUTURAS DO TIPO RVORE, ONDE O GRAU DE CADA N MENOR OU IGUAL A DOIS. NO CASO DE RVORES BINRIAS, DISTINGUEM-SE AS SUBRVORES DE UM N ENTRE SUBRVORE DA ESQUERDA E SUBRVORE DA DIREITA. ASSIM, SE O GRAU DE UM N FOR IGUAL A UM, DEVE SER ESPECIFICADO SE A SUA SUBRVORE A DA ESQUERDA OU A DA DIREITA.

RAZ

RVORES BINRIAS

RVORES n-RIAS

QUALQUER RVORE PODE SER TRANSFORMADA EM UMA RVORE BINRIA, FAZENDO-SE: LIGAR OS NS IRMOS REMOVER A LIGAO PAI-FILHO, EXCETO PARA O PRIMOGNITO.
EXEMPLO: A

C D E F

RVORE BINRIA IMPLEMENTAO

#include <stdio.h> #include <alloc.h> #include <stdlib.h> #include <conio.h> void construir(struct arvore *,char,char); struct arvore* coloca(struct arvore*,char,char); void mostra(struct arvore*); struct arvore{ struct arvore *esq; char dado; struct arvore *dir; } *raiz = NULL ;

void main() {clrscr() ; construir(raiz,'r',' '); if (raiz != NULL)

{ clrscr() ; printf("\n\n\amostrando a arvore"); printf("\n\nraiz da arvore = %c",(*raiz).dado) ; mostra(raiz); } {clrscr() ; printf("\a\n\na arvore esta vazia"); } getch() ; } else

RVORE BINRIA IMPLEMENTAO

void construir(struct arvore *filho,char lado,char letra) { char entra; struct arvore *onde; if (lado == 'r') printf("\ninforme a raiz: "); else if (lado == 'e') printf("\ninforme o filho esquerdo de %c: ",letra); else printf("\ninforme o filho direito de %c: ",letra); entra = getche(); if (entra != 13) { onde = coloca(filho,entra,lado); construir(onde,'e',entra); construir(onde,'d',entra); } }

RVORE BINRIA IMPLEMENTAO

struct arvore* coloca(struct arvore *atual,char quem,char ld) { struct arvore *alocou; alocou = (struct arvore*) malloc(sizeof(struct arvore)); (*alocou).dado = quem ; (*alocou).esq = NULL; (*alocou).dir = NULL; if (!raiz) raiz = alocou ; else if (ld == 'e') (*atual).esq = alocou; else (*atual).dir = alocou; return alocou; }

RVORE BINRIA IMPLEMENTAO

void mostra(arvore *ptr) { struct arvore *xyz; if (ptr) { xyz = (*ptr).esq; if (xyz) printf("\nfilho a esquerda de %c = %c", (*ptr).dado,(*xyz).dado); xyz = (*ptr).dir; if (xyz) printf("\nfilho a direita de %c = %c", (*ptr).dado,(*xyz).dado); mostra((*ptr).esq); mostra((*ptr).dir); } }

RVORE BINRIA IMPLEMENTAO

PROGRAM ARVORE ; USES CRT ; TYPE APONT = ^NODO ; NODO = RECORD ESQ : APONT ; DADO : CHAR ; DIR : APONT ; END ; VAR RAIZ : APONT ; FUNCTION COLOCA( ATUAL:APONT;QUEM:CHAR; LD:CHAR) : APONT ; VAR ALOCOU : APONT ; BEGIN NEW(ALOCOU) ; ALOCOU^.DADO := QUEM ; ALOCOU^.ESQ := NIL ; ALOCOU^.DIR := NIL ; IF (RAIZ = NIL) THEN RAIZ := ALOCOU ELSE IF (LD = 'e') THEN ATUAL^.ESQ := ALOCOU ELSE ATUAL^.DIR := ALOCOU ; COLOCA := ALOCOU ; END;

RVORE BINRIA IMPLEMENTAO

PROCEDURE CONSTRUIR (FILHO:APONT ; LADO:CHAR) ; VAR ENTRA : CHAR ; ONDE : APONT ; BEGIN IF (LADO = ' r ') then WRITE('INFORME A RAIZ: ') ELSE IF (LADO = ' e ') THEN WRITE('INFORME FILHO ESQUERDO DE , FILHO^.DADO,' ') ELSE WRITE('INFORME O FILHO DIREITO DE ', FILHO^.DADO,' ') ; ENTRA := READKEY ; WRITELN(ENTRA) ; IF (CHR(13) <> ENTRA) THEN BEGIN ONDE := COLOCA(FILHO,ENTRA,LADO) ; CONSTRUIR(ONDE,'e') ; CONSTRUIR(ONDE,'d') ; END ; END ;

RVORE BINRIA IMPLEMENTAO

PROCEDURE MOSTRA(PTR : APONT) ; BEGIN IF (PTR < > NIL) THEN BEGIN IF (PTR^.ESQ < > NIL) THEN WRITELN('FILHO ESQUERDO DE ',PTR^.DADO,' = ' ,(PTR^.ESQ)^.DADO) ; IF (PTR^.DIR < > NIL) THEN WRITELN('FILHO DIREITO DE ',PTR^.DADO,' = ' ,(PTR^.DIR)^.DADO) ; MOSTRA(PTR^.ESQ) ; MOSTRA(PTR^.DIR) ; END ; END ;

RVORE BINRIA IMPLEMENTAO

VAR A: CHAR ; BEGIN RAIZ := NIL ; CLRSCR ; CONSTRUIR(RAIZ,'r') ; IF (RAIZ < > NIL) THEN BEGIN WRITELN ; CLRSCR ; WRITELN('MOSTRANDO A ARVORE') ; WRITELN ; WRITELN('RAIZ DA ARVORE = ',RAIZ^.DADO) ; MOSTRA(RAIZ) ; END ELSE BEGIN CLRSCR ; WRITELN('A ARVORE ESTA VAZIA'); END ; A := READKEY ; END.

GRAFOS

CONCEITOS:
UM GRAFO G CONSTITUDO POR UM CONJUNTO N DE ELEMENTOS E POR UMA RELAO BINRIA A ENTRE ESSES ELEMENTOS. ESCREVE-SE: G = (N,A) A RELAO A, POR SUA VEZ, TAMBM UM CONJUNTO CUJOS MEMBROS SO PARES ORDENADOS (ni,nj), ONDE ni E nj SO ELEMENTOS DE N. OS ELEMENTOS DE N SO DENOMINADOS NS (OU VRTICES), ENQUANTO OS ELEMENTOS DE A SO DENOMINADOS ARCOS (OU ARESTAS). EXEMPLO: N = {1,2,3,4,5,6} A = {(1,2),(2,1),(2,3),(2,4),(3,3),(4,1),(4,3),(5,6)} QUE PODE SER REPRESENTADO GRAFICAMENTE: 2 1 4 3 5

GRAFOS

CONCEITOS E DEFINIES:

NS LIGADOS POR ARCOS SO DITOS ADJACENTES; NO GRAFO EXEMPLO O N 2 ADJACENTE A 1, 3 E 4. UM CAMINHO UMA SEQNCIA DE UM OU MAIS ARCOS EM QUE O SEGUNDO N DE CADA ARCO COINCIDE COM O PRIMEIRO DO SEGUINTE, PERMITINDO ATINGIR UM N B A PARTIR DE UM N A. UM GRAFO CONEXO QUANDO TEM UM N DO QUAL EXISTEM CAMINHOS PARA TODOS OS DEMAIS. O GRAFO DO EXEMPLO NO CONEXO, NO ENTANDO, O SUBGRAFO CONSTITUDO PELOS NS 1, 2, 3 E 4 CONEXO, POIS A PARTIR DO N 1 POSSVEL ATINGIR TODOS OS DEMAIS. QUANDO OS ARCOS QUE LIGAM OS NS DE UM GRAFO NO POSSUEM DIREO DEFINIDA (CABEA DE SETA) DIZ-SE QUE O GRAFO NO-DIRIGIDO. QUANDO OS ARCOS (OU ARESTAS) TEM VALORES ASSOCIADOS DIZ-SE QUE O GRAFO VALORADO. MTODOS DE BUSCA BUSCA EM PROFUNDIDADE

Este mtodo, tambm chamado de depth-first, consiste em explorar preferencialmente os descendentes de um n que

tenha sido avaliado em prejuzo dos vizinhos ou irmos deste n.

** ALGORITMO BUSCA-EM-PROFUNDIDADE **
CRIE DUAS PILHAS ABERTOS E FECHADOS INICIALIZE A PILHA ABERTOS = [N INCIO] ENQUANTO ABERTOS NO ESTIVER VAZIA FAA
REMOVA O N DO TOPO DE ABERTOS E CHAME-O DE X SE X CONCLUSIVO TERMINE COM SUCESSO SENO BUSQUE TODOS OS FILHOS DE X

DISPENSE OS FILHOS DE X QUE J ESTO EM ABERTOS OU

FECHADOS

COLOQUE SOBRE A PILHA ABERTOS OS FILHOS REMANESCENTES DE X (NA ORDEM EM QUE FORAM BUSCADOS??)

COLOQUE X SOBRE A PILHA FECHADOS

FIM ENQUANTO

MTODOS DE BUSCA BUSCA EM LARGURA

Este mtodo, em contraste com o mtodo da busca em profundidade, consiste em explorar os ns nvel-a-nvel. Neste

caso so priorizados os vizinhos ou irmos de um n que tenha sido avaliado em prejuzo dos descendentes .

** ALGORITMO BUSCA-EM-LARGURA **
CRIE DUAS FILAS ABERTOS E FECHADOS INICIALIZE A FILA ABERTOS = [N INCIO] ENQUANTO ABERTOS NO ESTIVER VAZIA FAA
REMOVA UM N DA FILA ABERTOS E CHAME-O DE X SE X CONCLUSIVO TERMINE COM SUCESSO SENO BUSQUE TODOS OS FILHOS DE X

DISPENSE OS FILHOS DE X QUE J ESTO EM ABERTOS OU

FECHADOS

COLOQUE NA FILA ABERTOS OS FILHOS REMANESCENTES DE X (NA ORDEM EM QUE FORAM BUSCADOS??)

COLOQUE X NA FILA FECHADOS

FIM ENQUANTO

MTODOS DE BUSCA GRAFO EXEMPLO

10

11

12

13

14

15

16

17

18

19

20

21

GRAFOS PROBLEMA DO MENOR CAMINHO

** ALGORITMO DE FLOYD **

P1 P2

K=0; CRIE A MATRIZ K DE CUSTOS (INICIAL) DE TAL MODO QUE d i i = 0 PARA TODO i = 1,2,3,...,n ; QUE d i j =

QUANDO NO EXISTE A ARESTA (xi , xj) E COM O VALOR DAS ARESTAS PARA OS DEMAIS ELEMENTOS P3 K = K + 1
P4
FAA d k
i j

MIN (d

k-1
i j

, (d
i k

k-1

+
k j

k-1

)]

P5 SE ALGUM d i i < 0, ENTO EXISTE UM CICLO DE CUSTO NEGATIVO CONTENDO O VRTICE X i E NO EXISTE SOLUO POSSVEL. PARE P6 0, E k = n , A SOLUO FOI ACHADA, E [d i j ] FORNECE OS COMPRIMENTOS DE TODOS OS MENORES CAMINHOS. PARE
i i ii

SE TODO d

P7 SE TODO d P3

0 MAS k < n , ENTO RETORNE A

GRAFOS - EXEMPLO PROBLEMA DO MENOR CAMINHO

V2

V3

5 V1 1

1 3 V4 1 1

5 V5

GRAFOS - EXEMPLO PROBLEMA DO MENOR CAMINHO

D0 =

0 1

5 0 1 1

3 0

3 0 1

5 1 0

D1 =

0 5 0

3 3

5 1 0

0 1 1 0 1 1

D2 =

0 5 0

8 3

3 5 0

0 1 1 4 0 1 1 4 1

D3 =
1

0 5 8 3 13 0 3 8 0 5 1 4 0 1 1 4 1

D4 =

0 1 2

4 0 1 1

7 3 0 4 4

3 0 1

4 8 5 1 0

0 10

4 0 6 1 1

7 3 0 4 4

3 9 6 0 1

4 8 5 1 0

D5 =

7
1 2