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;
}
}
}
