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;
}
int desempilhaFilaCircular (dado *fila, int *inicio, int *fim, dado *elemento, int NMAX){
if (filaVazia(fila, *inicio, *fim) == OK) {
//Coloca o valor do elemento da fila a ser desempilhado na posicao de memoria apontada por *elemento.
//Ele ja deve estar alocado! (i.e.: nao ser nulo)
if (elemento != NULL) {
//Pega o elemento no inicio da fila (FIFO)
*elemento = fila[(*inicio)++];
//Verifica se preciamos remapear 'inicio'
if (*inicio == NMAX) {
*inicio = 0;
}
return OK;
} else {
//Se nao estiver allocado, nao podemos coloca-lo na fila
return ELEMENTO_NAO_ALLOCADO;
}
} else {
//A fila esta vazia!
return UNDERFLOW;
}
}
/*!
* @return um generico que é a info do dado retirado.
* o método faz uma verificação para saber se a fila está vazia, sim joga uma
* exceção, caso não chama o método retiraDoInicio da lista encadeada e retorna
* ele.
* @see filaVazia(), Lista Enc retiraDoInicio()
*/
T retira() {
if (filaVazia()) {
throw "ERROFILAVAZIA";
} else {
return this->retiraDoInicio();
}
}
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;
}
}
T FilaEnc<T>::ultimo() {
if (filaVazia()) {
throw std::runtime_error("Fila Vazia");
} else {
return fim->getInfo();
}
}
T FilaEnc<T>::primeiro() {
if (filaVazia()) {
throw std::runtime_error("Fila Vazia");
} else {
return ListaEnc<T>::getHead()->getInfo();
}
}
/*!
* @return um genérico que vai ser a info do primeiro elemento da fila.
* o método começa fazendo a verificação se a fila está vazia ou não, se sim
* joga a exceção, se não é retornado a info do elemento head da listaEnc.
* o primeiro elemento da fila é o primeiro elemento que foi adicionado a ela,
* que no caso, é o head da lista.
* @see filaVazia()
*/
T primeiro() {
if (filaVazia()) {
throw "ERROFILAVAZIA";
} else {
return this->head->getInfo();
}
}
T Fila<T>::retira() {
if (filaVazia())
throw std::runtime_error("fila vazia");
inicio = (inicio+1) % MAXFILA;
return dados[inicio];
}
int Fila<T>::getUltimo() {
if (filaVazia())
throw std::runtime_error("fila vazia");
else if (fim < inicio)
return fim + (MAXFILA - inicio) - 1;
else
return fim - inicio - 1;
}
int filaPop(Fila* fila){ // Pop = Desempilhar
if(filaVazia(fila))
return -1;
else{
fila->begin++;
int c=fila->vetor[fila->begin-1];
return c;
}
}
void imprimeFila(tfila *f){
no *aux = f->inicio;
if(!filaVazia(*f)){
while(aux!=NULL){
printf("[%d]",aux->conteudo);
aux = aux->proximo;
}
}
}
T Fila<T>::remove(){
if(filaVazia()){
throw new EstruturaVaziaException;
}
numElementos--;
ElementoFila<T>* elemento = primeiroElemento;
primeiroElemento = primeiroElemento->getProx();
T dado = elemento->getDado();
delete elemento;
return dado;
}
void buscaFila(tfila *f,int x){
no *aux = f->inicio;
if(!filaVazia(*f)){
while(aux!=NULL){
if(x == aux->conteudo){
printf("[%d]",aux->conteudo);
}
aux = aux->proximo;
}
}
}
/*!
\return um elemento que ocupava o começo da fila
\sa inclui(), inicializaFila()
*/
T retira() {
if (filaVazia()) {
throw "Fila Vazia";
} else {
T first = dados[0];
last--;
for (int i = 0; i < last; i++) {
dados[i-1] = dados[i];
}
return first;
}
}
T Fila<T>::get(int pos){
if(filaVazia()){
throw new EstruturaVaziaException;
}else if(pos < 0 or pos > numElementos){
throw new PosicaoInvalidaException;
}
ElementoFila<T>* elemento = primeiroElemento;
for(int i = 0; i < pos; i++){
elemento = elemento->getProx();
}
return elemento->getDado();
}
//Funcao que adiciona uma nova carta no final do deck (fila)
void enfileira(int valor, char naipe, struct deck *p)
{
struct carta *nova;
nova = malloc(sizeof(struct carta));
nova->valor = valor;
nova->naipe = naipe;
nova->prox = NULL;
if(filaVazia(*p))
p->inicio = nova;
else
(p->fim)->prox = nova;
p->fim = nova;
}
int desenfileirar() {
if (filaVazia())
return 0;
int aux = dts[primeiro];
int i=0;
while(i <= TAM-1){
dts[i] = dts[i+1];
i++;
}
ultimo--;
tam--;
return aux;
}
no *desenfileirar(tfila *f){
no *aux = NULL;
if(!filaVazia(*f)){
aux = f->inicio;
if(f->inicio->proximo == NULL)
criaFila(f);
else{
f->inicio = (f->inicio)->proximo;
f->cont--;
}
}
return aux;
}
void FilaEnc<T>::inclui(const T& dado) {
Elemento<T>* novo = new Elemento<T>(dado, 0);
if(novo == 0) {
throw ExcecaoListaCheia();
}
if(filaVazia()) {
this->cabeca = novo;
} else {
fim->setProximo(novo);
}
novo->setProximo(0);
fim = novo;
this->tamanho++;
}
void mostraFila(Fila* f){
int i, cont;
if(!filaVazia(f)){
i = f->inicio;
for(cont = 0; cont < f->tamanhoFila; cont++){
printf("%d - ", f->vetFila[i]);
i = (i + 1) % f->comprimentoDoVetor;
}
}
else
P("Fila vazia!");
getch();
}
//Funcao que retorna o tamnho de uma fila
int tamanho(struct deck *p){
struct carta *aux;
int i=0;
if(filaVazia(*p))
return 0;
aux = p->inicio;
while(aux != p->fim){
aux = aux->prox;
i++;
}
return i;
}
T FilaEnc<T>::retira() {
if (filaVazia()) {
throw ExcecaoListaVazia();
}
Elemento<T>* sai = this->cabeca;
T volta = sai->getInfo();
this->cabeca = sai->getProximo();
if(this->tamanho == 1) {
fim = 0;
}
this->tamanho--;
delete sai;
return volta;
}
void Fila<T>::add(T dado){
ElementoFila<T>* elemento = new ElementoFila<T>(dado);
if(elemento != NULL){
if(filaVazia()){
primeiroElemento = elemento;
}else{
ultimoElemento->setProx(elemento);
}
numElementos++;
ultimoElemento = elemento;
}else{
throw new OutOfMemoryException;
}
}
int desenfilere (Fila* fila) {
Lista* t;
int v;
if (filaVazia(fila)) {
printf("\nFila vazia!\n");
return -1;
}
t = fila -> inicio;
v = t->info;
fila->inicio = t->prox;
if (fila->inicio == NULL) // verifica se fila ficou vazia
fila->fim = NULL;
free(t);
return v;
}
int removeFila(Fila* f){
int removido;
if(!filaVazia(f)){
removido = f->vetFila[f->inicio];
if(f->inicio == f->comprimentoDoVetor - 1)
f->inicio = 0;
else
f->inicio++;
f->tamanhoFila--;
}
return removido;
}
void enfileirar(tfila *f,int x){
no *novo_no = (no*)malloc(sizeof(no));
if(novo_no != NULL){
novo_no->proximo = NULL;
novo_no->conteudo = x;
if(filaVazia(*f)){
f->inicio = f->fim = novo_no;
}else{
(f->fim)->proximo = novo_no;
f->fim = novo_no;
}
f->cont++;
}
}
/*!
* @return um genérico que é o ultimo elemento da fila, o elemento que foi add
* recentemente.
* o método verifica se a fila está vazia, se sim joga uma exceção, se não ele
* cria três variaveis internas, uma do tipo generica, um ponteiro de tElemento
* e um inteiro inicializado em 1.
* o ponteiro andante recebe o elemento head da listaEncadeada, e equanto o cont
* for menor que o size da listaEncadeada, a variavel andante recebe o proximo
* elemento da fila, e o cont é incrementado. após o fim do laço o generico
* recebe a info do andante e é retornado.
* @see filaVazia()
*/
T ultimo() {
if (filaVazia()) {
throw "errofilavazia";
} else {
Elemento<T> *andante;
andante = this->head;
int cont = 1;
T ultimo;
while (cont < this->size) {
andante = andante->getProximo();
cont++;
}
ultimo = andante->getInfo();
return ultimo;
}
}
void exibeFilaCircular (dado *fila, int inicio, int fim, int NMAX) {
int c;
printf("\nImprimindo conteudo da fila:\n");
//Verifica se a fila esta vazia
if (filaVazia(fila, inicio, fim) == VAZIO) {
printf(" Fila vazia!\n");
return;
}
//Se nao estiver, imprime o conteudo.
//O processo eh dividido em dois casos:
//Se fim > inicio, temos uma estrutura linear, e podemos repetir o que foi visto
//na fila linear
//Se inicio > fim, devemos imprimir tudo que esta depois de 'inicio' ate o final do
//vetor e depois voltar ao indice 0, imprimindo ate 'fim'
if (fim > inicio) {
//Imprime normalmente
for (c = inicio; c < fim; c++) {
printf(" Elemento %d, Indice %d: %d\n", c - inicio, c , fila[c]);
}
} else {
//Imprime de inicio ate o fim do vetor
for (c = inicio; c < NMAX; c++) {
printf(" Elemento %d, Indice %d: %d\n", c - inicio, c , fila[c]);
}
//Imprime do elemento 0 ate fim
for (c = 0; c < fim; c++) {
printf(" Elemento %d, Indice %d: %d\n", (NMAX - inicio) + c, c , fila[c]);
}
}
}
void percurso_em_largura(ABP a, void (*mostra_info)(void *) ){
if(a.raiz == NULL)
printf("Arvore vazia!\n");
else{
printf("Percurso em largura:\n\n");
FilaEncadeada f;
inicializaFila(&f, sizeof(NoABP)); // Fila de nós da árvore
inserir(&f, a.raiz); // O campo "raiz" é um ponteiro, portanto, não precisa do "&"...
while(!filaVazia(f)){
NoABP n;
remover(&f, &n);
(*mostra_info)(n.info); // Mostra nó (1o. da fila)
if(n.esq != NULL) // Insere filhos na fila
inserir(&f, n.esq);
if(n.dir != NULL)
inserir(&f, n.dir);
}
limpaFila(&f);
}
printf("----------------------\n\n");
}
int grafo(int w, int n, int matrix[][maxtam]){
int i, q, cont=0;
Fila* espera;
Fila* visitados;
espera = filaConstrutor();
visitados = filaConstrutor();
filaPush(w,espera); //s é a cordenada do último ponto visitado
filaPush(w,visitados);
while(filaVazia(espera) == 0){
int a=filaPop(espera); //o elemento da fila
cont++;
for (i = 1; i <= n; i++){ //printf("matrix[a][i]%d a:%d i:%d\n",matrix[a][i], a,i);
if(matrix[a][i]==1)
if(!verificaRepetido(i,espera)){
filaPush(i,espera);// printf("Varrendo Matriz:%d\n",i);
filaPush(i,visitados);
}
}
}
//if(cont != n)
// return 0;
//else
return 1;
}
