Algoritmos e Estruturas de Dados I

Algoritmos e Estruturas de Dados I Prof. Daniel M. Martin (daniel.martin@ufabc.edu.br) Aula 8

Aplicação de Fila Calcular a distância entre pessoas no Facebook

Aplicação de Fila Calcular a distância entre pessoas no Facebook Amanda Paul

Aplicação de Fila Algorítmo para achar distância entre a e b:

Aplicação de Fila Algorítmo para achar distância entre a e b: a

Aplicação de Fila Algorítmo para achar distância entre a e b: d a f p g

Aplicação de Fila Algorítmo para achar distância entre a e b: a d f p g k s e j

Aplicação de Fila Algorítmo para achar distância entre a e b: d k a f p s t r g e c j

Aplicação de Fila Algorítmo para achar distância entre a e b: d k h a f p g s e t r c m b j

Onde está a fila neste algoritmo? BUSCA_EM_LARGURA(a, b) visitados Ø F fila vazia distância[a] 0 enfileira a em F enquanto F Ø faça x desenfileira elemento de F para cada amigo y de x faça se y = b então imprime dist de a até b é + distância[y] se y visitados então visitados visitados { y } distância[y] distância[ x] + 1 enfileira y em F

Simulação da busca em largura FILA: a d k h a f p g s e t r c m b j

Simulação da busca em largura FILA: a, d k h a f p g s e t r c m b j

Simulação da busca em largura FILA: a, d d k h a f p g s e t r c m b j

Simulação da busca em largura FILA: a, d, f d k h a f p g s e t r c m b j

Simulação da busca em largura FILA: a, d, f, p d k h a f p g s e t r c m b j

Simulação da busca em largura FILA: a, d, f, p, g d k h a f p g s e t r c m b j

Simulação da busca em largura FILA: a, d, f, p, g, k d k h a f p g s e t r c m b j

Simulação da busca em largura FILA: a, d, f, p, g, k, s d k h a f p g s e t r c m b j

Simulação da busca em largura FILA: a, d, f, p, g, k, s, e d k h a f p g s e t r c m b j

Simulação da busca em largura FILA: a, d, f, p, g, k, s, e, j d k h a f p g s e t r c m b j

Simulação da busca em largura FILA: a, d, f, p, g, k, s, e, j, t d k h a f p g s e t r c m b j

Simulação da busca em largura FILA: a, d, f, p, g, k, s, e, j, t, r d k h a f p g s e t r c m b j

Simulação da busca em largura FILA: a, d, f, p, g, k, s, e, j, t, r, c d k h a f p g s e t r c m b j

Simulação da busca em largura FILA: a, d, f, p, g, k, s, e, j, t, r, c, h d k h a f p g s e t r c m b j

Simulação da busca em largura FILA: a, d, f, p, g, k, s, e, j, t, r, c, h, m d k h a f p g s e t r c m b j

Simulação da busca em largura FILA: a, d, f, p, g, k, s, e, j, t, r, c, h, m, b d k h a f p g s e t r c m b j

Algoritmo de Busca em Largura BUSCA_EM_LARGURA(a, b) visitados Ø F fila vazia distância[a] 0 enfileira a em F enquanto F Ø faça x desenfileira elemento de F para cada amigo y de x faça se y = b então imprime dist de a até b é + distância[y] se y visitados então visitados visitados { y } distância[y] distância[ x] + 1 enfileira y em F

Pilha (Stack)

Pilha Lista dinâmica de objetos Todos os objetos são do mesmo tipo (assim como nos vetores, listas ligadas e filas)

Pilha Lista dinâmica de objetos Todos os objetos são do mesmo tipo (assim como nos vetores, listas ligadas e filas) O que caracteriza uma pilha é a ordem de remoção dos elementos

Pilha Lista dinâmica de objetos Todos os objetos são do mesmo tipo (assim como nos vetores, listas ligadas e filas) O que caracteriza uma pilha é a ordem de remoção dos elementos Elementos são removidos na ordem contrária em que são inseridos

Pilha Lista dinâmica de objetos Todos os objetos são do mesmo tipo (assim como nos vetores, listas ligadas e filas) O que caracteriza uma pilha é a ordem de remoção dos elementos Elementos são removidos na ordem contrária em que são inseridos LIFO = last in first out

Pilha Operações de inserção e remoção têm nomes especiais em inglês: push e pop

Simulação de Pilha push(10) push(12) push(29) push(34) pop() push(17) pop() pop()

Simulação de Pilha push(10) push(12) push(29) push(34) pop() push(17) pop() pop() 10

Simulação de Pilha push(10) push(12) push(29) push(34) pop() push(17) pop() 12 pop() 10

Simulação de Pilha push(10) push(12) push(29) push(34) pop() push(17) pop() 29 12 pop() 10

Simulação de Pilha push(10) push(12) push(29) push(34) pop() push(17) pop() 34 29 12 pop() 10

Simulação de Pilha push(10) push(12) push(29) push(34) pop() devolve 34 push(17) pop() 29 12 pop() 10

Simulação de Pilha push(10) push(12) push(29) push(34) pop() push(17) pop() 17 29 12 pop() 10

Simulação de Pilha push(10) push(12) push(29) push(34) pop() push(17) pop() devolve 17 29 12 pop() 10

Simulação de Pilha push(10) push(12) push(29) push(34) pop() push(17) pop() 12 pop() devolve 29 10

Pilha Para armazenar os elementos de uma pilha, a implementação pode usar: Um vetor Uma lista ligada Veremos em sala apenas a implementação usando vetor

Implementação (não modular) Podemos utilizar um vetor v e variáveis N capacidade da pilha (tamanho do vetor) n numero de elementos na pilha

Implementação (não modular) Podemos utilizar um vetor v e variáveis N capacidade da pilha (tamanho do vetor) n numero de elementos na pilha A operação push(x) pode ser feita pelo código v[n ++] = x; A operação x = pop() é feita pelo código x = v[-- n];

Codigo da Simulação Anterior int v[8], N = 8, n = 0, x; v[n ++] = 10; // push(10) v[n ++] = 12; // push(12) v[n ++] = 29; // push(29) v[n ++] = 34; // push(34) x = v[-- n]; // pop() faz x = 34 v[n ++] = 17; // push(17) x = v[-- n]; // pop() faz x = 17 x = v[-- n]; // pop() faz x = 29

Interface: pilha.h #include "item.h" #ifndef ARQUIVO_PILHA_H #define ARQUIVO_PILHA_H typedef void *pilha; // retorna pilha com espaço p/ N itens pilha nova_pilha(int N); // quando a pilha não for mais ser usada: void libera_pilha(pilha P);

Interface: pilha.h (cont.) // retorna 0 se a pilha P estiver vazia int pilha_vazia(pilha P); // insere item x na pilha P void push(pilha P, item x); // devolve último elemento da pilha P, // e o remove da pilha item pop(pilha P); // devolve último elemento sem removê-lo item topo_pilha(pilha P); #endif

Implementação: pilha.c #include <stdio.h> #include <stdlib.h> #include "item.h" #include "pilha.h" typedef struct s_pilha *p_pilha; struct s_pilha { // vetor que armazena os itens da pilha item *v; // guarda o número de itens na pilha int n; };

Implementação: pilha.c (cont.) pilha nova_pilha(int N) { p_pilha mp = (p_pilha) malloc(sizeof( struct s_pilha)); if (mp == NULL) { /* testa falha */ } mp->v = malloc(n * sizeof(item)); mp->n = 0; } if (mp->v == NULL) { /*... */ } return (pilha) mp;

Implementação: pilha.c (cont.) void libera_pilha(pilha P) { p_pilha mp = (p_pilha) P; } free(mp->v); free(mp); int pilha_vazia(pilha P) { p_pilha mp = (p_pilha) P; } return mp->n == 0;

Implementação: pilha.c (cont.) void push(pilha P, item x) { p_pilha mp = (p_pilha) P; } // v[n ++] = x; mp->v[mp->n ++] = x; item pop(pilha P) { p_pilha mp = (p_pilha) P; } // return v[-- n]; return mp->v[-- mp->n];

Aplicação de Pilha Verificar se expressões contendo os seis símbolos ( [ { ) ] } são bem formadas Exemplo: (())[()] é bem formada, ([(){}]) é bem formada, ([{(})]) não é bem formada.

Aplicação de Pilha int bem_formada(char *s, int n) { int i; pilha P = nova_pilha(n); for (i = 0; i < n; i ++) switch (s[i]) { case ')': case ']': case '}': if (pilha_vazia(p) topo_pilha(p)!= s[i]) return 0; else pop(p); break;

Aplicação de Pilha } case '(': push(p, ')'); break; case '[': push(p, ']'); break; case '{': push(p, '}'); break; default: return 0; // símbolo inválido } return pilha_vazia(p);

Aplicação de Pilha Simular na lousa o algoritmo com entrada [ ( { ( ( ) { } ] } ) ] Simular na lousa o algoritmo com entrada [ ( ) ] { }

Outra Aplicação Calculadora de notação pósfixa Exemplo: 2 1 * 3 * 8 7 5 + + + (na lousa)