void consumidor(Shared *shm) { int j, n; while(1) { /* Se o produtor nao vai mais produzir, o proprio consumidor tem que liberar o seu semaforo */ if(shm->termina) { sem_post(&shm->c_sem); /* Se a pilha ficar vazia e o produtor nao vai mais produzir, terminou a tarefa */ if(pilhaVazia(&shm->pilha)) break; } /* Aguarda ate semaforo ficar verde */ sem_wait(&shm->c_sem); /* Cada consumidor vai consumir entre 0 e 9 vezes por ciclo */ n = randomNumber(0, 9); printf("[PID: %d] Consumir: %d vezes\n", getpid(), n); /* Consome N vezes por ciclo */ for(j = 0; j < n; j++) { if(!pilhaVazia(&shm->pilha)) { printf("[PID: %d] Consumindo: %d\n", getpid(), topoPilha(&shm->pilha)); desempilha(&shm->pilha); } else { printf("[PID: %d] Pilha esvaziou! Lote teve %d unidades\n", getpid(), j); break; } } /* Libera produtor */ sem_post(&shm->p_sem); } }
// retorna o elemento, ou '' se nao tiver elemento char removePilha(Pilha *p){ if (pilhaVazia(p)) return '\0'; p->tam--; return p->pilha[p->tam]; }
int elementoTopo(pilha p, float *valor){ if(pilhaVazia(p)) return 0; *valor = p.P[p.topo]; return *valor; }
T Pilha<T>::remove(){ if(pilhaVazia()) throw new EstruturaVaziaException; numElementos--; ElementoPilha<T>* elemento = topo->getAnt(); T dado = topo->getDado(); delete topo; topo = elemento; return dado; }
int pop(t_pilha* pilha) { if(pilhaVazia(pilha)) { printf("Ocorreu underflow na pilha!\n"); liberaPilha(pilha); exit(1); } return pilha->item[pilha->topo--]; }
void Pilha<T>::add(T dado){ ElementoPilha<T>* elemento = new ElementoPilha<T>(dado); if(elemento == NULL) throw new OutOfMemoryException; if(!pilhaVazia()){ elemento->setAnt(topo); topo->setProx(elemento); } numElementos++; topo = elemento; }
int pop(PILHA *p){ int x; if(pilhaVazia(p)) //UNDERFLOW return 0; //*elem = (p->pilha[p->topo-1]); x = p->pilha[p->topo-1]; p->topo--; return x; }
void imprimirPilha(t_pilha* pilha) { int i; if(pilhaVazia(pilha)) { printf("Pilha Vazia!\n"); return; } printf("++++++++++++++++++++++++++\n"); for(i = pilha->topo; i > VAZIA; i--) printf("%d\n", pilha->item[i]); }
/** * Função responsável por implementar o algoritmo de backtracking propriamente dito * de maneira iterativa para varrer o espaço de estados. Se encontrar uma * resposta válida retorna um vetor com maxMov posições contendo os passos a serem * seguidos, senão retorna NULL. */ movimento* buscaSolucao(jogo oJogo, estado *inicial){ estado *atual = inicial; do { if(!empilhaCandidatos(oJogo, atual)) { if(matrizesIguais(oJogo.obj, atual->tabuleiro, oJogo.l, oJogo.c)) return atual->passos; if(pilhaVazia(oJogo.candidatos)) return NULL; } desalocaEstado(atual, oJogo.l); atual = desempilha(oJogo.candidatos); } while(TRUE); }
void buscaProfundidade(int V, int grafo[V][V], int ini){ LISTA lista; PILHA pilha; int i =0, j=0; //linha, coluna int aux, comp, k; lista.fim = 0; lista.vetor[0] = ini; lista.fim ++; InicializaPilha(); criaPilha(&pilha); push(&pilha, ini); while( pilhaVazia(&pilha) != 1 ){ //enquanto a pilha nao for vazia for(j = 0; j < V; j++){ if(grafo[i][j] == 1){ //se achou aresta comp = 0; k =0; for(k = 0; k < lista.fim; k++) //ok verifica se ja foi visitado if (j == lista.vetor[k]) comp = 1; if(comp == 0){ push(&pilha, j); } } } aux = pop(&pilha); //aux recebe o ultimo conteudo da pilha i = aux; for(k =0; k < lista.fim; k++){ //verifica se já foi visitado if(i == lista.vetor[k]) aux = pop(&pilha); i = aux; } lista.vetor[lista.fim] = aux; //enfileira o ultimo conteudo lista.fim++; } for(i =0; i<V; i++) printf("%d ", lista.vetor[i]); }
/** * Função responsável por, caso a pilha não esteja vazia desempilhar o * elemento do topo da pilha e retornar um ponteiro para ele, senão, * retornar NULL. */ tInfo* desempilha(pilha *aPilha){ tInfo *infoSai; tElemento *sai; if(pilhaVazia(aPilha)){ return NULL; } sai = aPilha->topo; infoSai = sai->info; aPilha->topo = sai->proximo; aPilha->numElementos--; free(sai); return infoSai; }
void removerValor(pilha *p, int x){ if(!pilhaVazia(*p)){ pilha aux; if(p->conteudo[p->topo] == x){ p->topo--; }else{ int i = p->topo; criaPilha(&aux); while(p->conteudo[i] != x){ empilha(&aux,p->conteudo[i]); desenpilha(p); i--; } i = aux.topo-1; while(i > 0){ empilha(p,aux.conteudo[i]); i--; } } } }
/** * Função responsável por desalocar todas estruturas de dados remanecentes do * cálculo da resposta ao jogo dado. */ void encerraJogo(jogo oJogo){ while(!pilhaVazia(oJogo.candidatos)) desalocaEstado(desempilha(oJogo.candidatos), oJogo.l); desalocaMatriz(oJogo.obj, oJogo.l); free(oJogo.candidatos); }
void desenpilha(pilha *p){ if(pilhaVazia(*p)) printf("Pilha Vazia!"); else p->topo--; }
int main(int argc, char const *argv[]) { Arvore *aux; int *val, h = 0; ItemPilha *item; H = atoi(argv[1]); while (H < 2) { printf("Digite um numero maior que ou igual a 2\n"); scanf("%d", &H); } exec = pilhaCriar(); val = (int *) malloc(sizeof(int)); *val = h; arv = arvCriarNo((void *) val, arvCriarNo(NULL, arvCriarVazia(), arvCriarVazia()), arvCriarNo(NULL, arvCriarVazia(), arvCriarVazia()) ); /* Incremento que sinaliza para a pilha que os itens empilhados terao altura * uma unidade maior que a altura atual */ ++h; item = itemCriar(arv->dir, h); pilhaInserir(exec, (void *) item); item = itemCriar(arv->esq, h); pilhaInserir(exec, (void *) item); do { /* Retira item da pilha de execucao */ // item = (ItemPilha *) pilhaRetirar(exec); // processaItem(item, &aux); processaItem((ItemPilha *) pilhaRetirar(exec), &aux); h = (*(int *)aux->info) + 1; // proxima altura /* Se a condicao de parada ainda nao tiver sido alcancada, ou seja, * se a altura do no criado nao tiver chegado ao limite de altura estabelecido * * Outros nos com alturas maiores devem ser colocados na pilha de execucao * para serem criados assim que essa volta do loop terminar */ if (h < H){ /* Cria um no filho do no atual na arvore e coloca na pilha de execucao * para ser processado (direita) */ // aux->dir = arvCriarNo(NULL, arvCriarVazia(), arvCriarVazia()); // item = itemCriar(aux->dir, h); // pilhaInserir(exec, (void *) item); // // /* Cria um no filho do no atual na arvore e coloca na pilha de execucao // * para ser processado (esquerda) // */ // aux->esq = arvCriarNo(NULL, arvCriarVazia(), arvCriarVazia()); // item = itemCriar(aux->esq, h); // pilhaInserir(exec, (void *) item); addProximos (&aux, h); } } while (!pilhaVazia(exec)); arvImprimir(arv); printf("\n"); return 0; }
/** * Função responsável por, caso a pilha não esteja vazia retornar um ponteiro * para o elemento do topo da pilha, senão, retornar NULL. */ tInfo* verTopo(pilha *aPilha){ if(!pilhaVazia(aPilha)) return aPilha->topo->info; return NULL; }
void infixToPostfix(char expr[], Pilha *p, char post[]) { int i = 0; int count = 0; int abriuParentesis = 0; // flag para indicar se abriu parentesis // limpar o post post[0] = '\0'; // para evitar: a+b+ char ultimo = expr[strlen(expr) - 1]; // Garante que a string possui somente caracteres validos i = 0; while (i < MAX && expr[i] != '\0' && expr[i] != '\n') { if (!operadorValido(expr[i])) { strcpy(post,"Lexical Error!"); return; } i++; } i = 0; while (i < MAX && expr[i] != '\0' && expr[i] != '\n') { // do infix to postfix if (simbolo(expr[i])) { // para evitar: aa+bb, a(b+c) if (i+1 != MAX && (simbolo(expr[i + 1]) || expr[i + 1] == '(')) { strcpy(post,"Syntax Error!"); return; } // concatena o na string posfixa post[count] = expr[i]; post[count + 1] = '\0'; count++; } else { // para evitar: a++b if (expr[i]=='(' && !simbolo(expr[i+1]) || (expr[i]!='(' && expr[i]!=')') && (expr[i+1]!='(' && expr[i+1]!=')') && !simbolo(expr[i+1]) ) { strcpy(post,"Syntax Error!"); return; } if (pilhaVazia(p) || expr[i]=='(' || abriuParentesis) { inserePilha(p, expr[i]); abriuParentesis = expr[i] == '(' ? 1 : 0; } else if (expr[i] == ')') { while (!pilhaVazia(p) && topo(p) != '(') { // remove da pilha e insere na string post[count] = removePilha(p); post[count + 1] = '\0'; count++; } // caso encontre o '(' remove da pilha if (pilhaVazia(p)) { strcpy(post,"Syntax Error!"); return; } else { removePilha(p); abriuParentesis = 0; } } else { if (temPrecedencia(topo(p), expr[i])) { do { post[count] = removePilha(p); post[count + 1] = '\0'; count++; } while (!pilhaVazia(p) && temPrecedencia(topo(p), expr[i])); inserePilha(p, expr[i]); } else { inserePilha(p, expr[i]); } } } i++; } if (operadorValido(ultimo) && !simbolo(ultimo) && ultimo != ')') { strcpy(post,"Syntax Error!"); return; } while(!(pilhaVazia(p))) { post[count] = removePilha(p); post[count + 1] = '\0'; count++; } // verifica se faltou fechar algum parentesis for (i = 0; i < count; i++) { if (post[i] == '(') { strcpy(post,"Syntax Error!"); return; } } }