void BFS(int graph[MAXN][MAXN], int raiz, int N) {
int fila[MAXN], i, inicioFila = 0, fimFila = -1, inicioComponente = 0, fimComponente = -1;
int atual;
cor[raiz] = CINZA;
inicFila(fila);
inicFila(componente);
insereFila(fila, inicioFila, &fimFila, raiz);
insereFila(componente, inicioComponente, &fimComponente, raiz);
while(!filaVazia(fila, inicioFila, fimFila)) {
atual = retiraFila(fila, &inicioFila, fimFila);
for (i = 0; i < N; i++) {
if(i != atual) {
if(graph[atual][i] > 0) {
if(cor[i] == BRANCO) {
cor[i] = CINZA;
insereFila(fila, inicioFila, &fimFila, i);
insereFila(componente, inicioComponente, &fimComponente, i);
}
}
}
}
cor[atual] = PRETO;
}
}
int main(){
Fila* f;
int tam, op;
P("Informe o tamanho da fila circular: ");
scanf("%d", &tam);
f = criaFila(tam);
do{
system("cls");
P("Escolha uma das opcoes abaixo --\n");
P("\t1. Inserir um elemento na fila circular;\n");
P("\t2. Remover um elemento da fila circular;\n");
P("\t3. Fila vazia ?\n");
P("\t4. Mostrar a fila circular;\n");
P("\t5. Sair.\n");
P("Resposta escolhida: ");
scanf("%d", &op);
switch(op){
case 1:{
int valor;
P("Digite o valor a ser inserido na fila circular: ");
scanf("%d", &valor);
insereFila(f, valor);
}
break;
case 2: {
if(filaVazia(f))
P("Fila vazia.\n");
else
printf("Valor removido: %d.\n", removeFila(f));
getch();
}
break;
case 3: {
if(filaVazia(f))
P("Fila vazia.\n");
else
P("Fila nao esta vazia.\n");
getch();
}
break;
case 4: mostraFila(f);
break;
case 5: exit(0);
break;
default : {
P("Opcao invalida.\n");
getch();
}
break;
}
}while(op != 5);
getch();
return 0;
}
void buscaLargura(Grafo g, int partida)
{
int i, v, a, w;
Fila fila = criaFila();
Lista listaBrancos = criaLista();
Lista listaPretos = criaLista();
Lista listaVisitados = criaLista();
for(i = GVprimeiroVertice(g); i != 0; i = GVproximoVertice(g, i))
{
insereNaLista(listaBrancos, i);
}
printf("Todas os vértices estão brancos.\n");
printf("Nenhuma aresta foi visitada.\n");
v = partida;
printf("O vertice %d está cinza.\n", v);
insereFila(fila, v);
retiraLista(listaBrancos, pegaPosLista(listaBrancos, v));
while(!vaziaFila(fila))
{
v = retiraFila(fila);
printf("Vertice %d ativado.\n", v);
for(a = GAprimaSaida(g,v); a != 0; a = GAproxSaida(g,v,a))
{
insereNaLista(listaVisitados, a);
printf("A aresta %d foi visitada.\n", a);
w = GVvizinho(g,a,v);
if(existeNaLista(listaBrancos, w))
{
insereFila(fila, w);
printf("O vertice %d está cinza.\n", w);
retiraLista(listaBrancos, pegaPosLista(listaBrancos, w));
}
}
insereNaLista(listaPretos, v);
printf("O vertice %d está preto.\n", v);
printf("Vertice %d desativado.\n", v);
}
destroiLista(listaBrancos);
destroiLista(listaPretos);
destroiFila(fila);
}
//Função responsável por realizar a busca em largura no grafo
int bfs(){
// Cria um vetor para marcar quais vértices já foram visitados
int *visited, n;
visited = (int *)malloc(numVertices * sizeof(int));
if(visited == NULL){printf("Falta de memoria!\n");exit(0);}
for(int i = 0; i < numVertices; i++){
visited[i] = 0;
}
// Cria a fila para executar a busca em largura
struct fila *q = NULL, *fim = NULL;
q = insereFila(q, &fim, inicio);
visited[inicio] = 1;
pai[inicio] = -1;
// Inicia a busca em largura
while (q != NULL){
int u = q->val;
q = removeFila(q);
for (int v=0; (v<numVertices); v++){
if (visited[v]==0 && redeResidual[u][v] > 0){
q = insereFila(q, &fim, v);
pai[v] = u;
visited[v] = 1;
if(v == destino){
n = visited[destino];
free(visited);
q = limpaFila(q, &fim);
return (n == 1);
}
}
}
}
// Retorna verdadeira caso encontre um novo caminho da superorigem até o superdestino
// Retorna falso, caso contrário
n = visited[destino];
free(visited);
q = limpaFila(q, &fim);
return (n == 1);
}
void testeFila () {
//Define o tamanho maximo da fila
int NMAX = 100;
//Inicializa o vetor onde a fila sera armazenada
dado *fila = malloc(sizeof(dado) * NMAX);
//Cria os indicadores de inicio e fim
int inicio, fim;
//Inicializa a fila
criaFila(fila, NMAX, &inicio, &fim);
//Insere 2 elementos
insereFila(fila, &inicio, &fim, 3, NMAX);
insereFila(fila, &inicio, &fim, 10, NMAX);
//Exibe a fila atual
exibeFila(fila, inicio, fim);
//Desempilha um elemento e imprime
dado desempilhado;
desempilhaFila(fila, &inicio, &fim, &desempilhado);
printf("\nElemento desempilhado: %d\n", desempilhado);
//Mostra a nova fila
exibeFila(fila, inicio, fim);
printf("\nForcando underflow:\n");
//Forca underflow
while (desempilhaFila(fila, &inicio, &fim, &desempilhado) == OK) {
printf(" Desempilhei alguem...\n");
}
printf(" Underflow!\n");
//Mostra a fila apos o overflow
exibeFila(fila, inicio, fim);
printf("\nVou empilhar para ver se ainda funciona:\n");
//Empilha coisas para ver se ainda funciona
if (insereFila(fila, &inicio, &fim, 10, NMAX)==OK) printf(" Tudo ok!\n");
//Mostra a fila apos insercao
exibeFila(fila, inicio, fim);
printf("\nForcando Overflow!\n");
//Empilha ate ter overflow
while (insereFila(fila, &inicio, &fim, 0, NMAX) == OK);
printf(" Overflow!\n");
//Se quiser ver:
//exibeFila(fila, inicio, fim);
printf("\nDesempilhando um elemento e tentando reempilhar:\n");
//Desempilha um elemento e tenta empilhar outro:
desempilhaFila(fila, &inicio, &fim, &desempilhado);
if (insereFila(fila, &inicio, &fim, 0, NMAX) == OK) {
printf(" Empilhado com sucesso.\n");
} else {
printf(" Ueh... Pq nao empilhou?\n");
}
//O empilhamento falou por causa da implementacao linear da fila.
//Observe o processo ate agora:
/*
Inicial: Empilhamento Empilhamento Desempilhamento
|| -> |elm1| -> |elm1|elm2| -> |elm2|
inicio = fim inic; fim+1 inicio fim+2 inic+1 fim+2
*/
//Ao desempilharmos, nao mudamos o incide de 'fim', mas sim apenas o indice de 'inicio'
//Isso faz com que a fila ainda pareca cheia quando se tenta empilhar um elemento, mesmo
//que haja espaco no comeco do vetor.
//Isso motiva a implementacao circular das filas (Veja exemplo).
}
