C Calculo de pilhas em linguagem C

[Visitante]

Boa noite, estou com meu grupo tentando fazer um cálculo de pilhas em C, porém não estou conseguindo identificar como fazer isso. O calculo consiste em pegar os dois últimos valores da pilha, e escolher a operação que será realizada. No momento temos isso:

 

#include <stdio.h>

#include <stdlib.h>

 

struct Node{

int num;

struct Node *prox;

};

typedef struct Node node;

 

int tam;

float x, y, z;

char oper;

 

int menu(void);

void inicia(node *PILHA);

void opcao(node *PILHA, int op);

void exibe(node *PILHA);

void libera(node *PILHA);

void push(node *PILHA);

void calcPilha(node *PILHA);

node *pop(node *PILHA);

 

int main(void)

{

node *PILHA = (node *) malloc(sizeof(node));

if(!PILHA){

printf("Sem memoria disponivel!\n");

exit(1);

}else{

inicia(PILHA);

int opt;

 

do{

opt=menu();

opcao(PILHA,opt);

}while(opt);

 

free(PILHA);

return 0;

}

}

 

void inicia(node *PILHA)

{

PILHA->prox = NULL;

tam=0;

}

 

int menu(void)

{

int opt;

 

for (;;)

{

 

printf(" ____________________\n");

printf("| Escolha a opcao |\n");

printf("|--------------------|\n");

printf("| 0. Sair |\n");

printf("| 1. Zerar PILHA |\n");

printf("| 2. Exibir PILHA |\n");

printf("| 3. PUSH |\n");

printf("| 4. POP |\n");

printf("| 5. CALCULADORA |\n");

printf("|____________________|\n");

printf(" ____________________\n| Opcao: ");

scanf("%d", &opt);

 

system("clear");

 

return opt;

}

 

}

 

void opcao(node *PILHA, int op)

{

node *tmp;

switch(op){

case 0:

libera(PILHA);

break;

 

case 1:

libera(PILHA);

inicia(PILHA);

break;

 

case 2:

exibe(PILHA);

break;

 

case 3:

push(PILHA);

break;

 

case 4:

tmp= pop(PILHA);

if(tmp != NULL)

printf("Retirado: %3d\n\n", tmp->num);

break;

 

case 5:

printf("Utilize os símbolos abaixo para realizar as operações:""\n""\n"

"(+)SOMA""\n"

"(-)SUBTRAÇÃO""\n"

"()MULTIPLICAÇÃO""\n"

"(/)DIVISÃO""\n"

"\n");

printf("Escreva o símbolo da operação que deseja realizar: ");

scanf("%s", &oper);

 

if (oper == '+')

{

printf("Digite o segundo valor: ");

scanf("%f", &y);

z = x + y;

}

if (oper == '-')

{

printf("Digite o segundo valor: ");

scanf("%f", &y);

z = x - y;

}

if (oper == '*')

{

printf("Digite o segundo valor: ");

scanf("%f", &y);

z = x * y;

}

if (oper == '/')

{

printf("Digite o segundo valor: ");

scanf("%f", &y);

z = x / y;

}

printf("%f", z);

break;

 

default:

printf("Comando invalido\n\n");

}

}

 

int vazia(node *PILHA)

{

if(PILHA->prox == NULL)

return 1;

else

return 0;

}

 

node *aloca()

{

node *novo=(node *) malloc(sizeof(node));

if(!novo){

printf("Sem memoria disponivel!\n");

exit(1);

}else{

printf("Novo elemento: "); scanf("%d", &novo->num);

return novo;

}

}

 

void exibe(node *PILHA)

{

if(vazia(PILHA)){

printf("\n\nPILHA vazia!\n\n");

return ;

}

 

node *tmp;

tmp = PILHA->prox;

printf("PILHA:");

while( tmp != NULL){

printf("%5d", tmp->num);

tmp = tmp->prox;

}

printf("\n ");

int count;

for(count=0 ; count < tam ; count++)

printf(" ^ ");

printf("\nOrdem:");

for(count=0 ; count < tam ; count++)

printf("%5d", count+1);

 

printf("\n\n");

}

 

void libera(node *PILHA)

{

if(!vazia(PILHA)){

node *proxNode,

*atual;

 

atual = PILHA->prox;

while(atual != NULL){

proxNode = atual->prox;

free(atual);

atual = proxNode;

}

}

}

 

void push(node *PILHA)

{

node *novo=aloca();

novo->prox = NULL;

 

if(vazia(PILHA))

PILHA->prox=novo;

else{

node *tmp = PILHA->prox;

 

while(tmp->prox != NULL)

tmp = tmp->prox;

 

tmp->prox = novo;

}

tam++;

}

 

void calcPilha(node *PILHA)

{

scanf("%s", &oper);

 

if (oper == '+')

{

printf("Digite o segundo valor: ");

scanf("%f", &y);

z = x + y;

}

if (oper == '-')

{

printf("Digite o segundo valor: ");

scanf("%f", &y);

z = x - y;

}

if (oper == '*')

{

printf("Digite o segundo valor: ");

scanf("%f", &y);

z = x * y;

}

if (oper == '/')

{

printf("Digite o segundo valor: ");

scanf("%f", &y);

z = x / y;

}

printf("%f", z);

return calcPilha(PILHA);

}

 

node *pop(node *PILHA)

{

if(PILHA->prox == NULL){

printf("PILHA ja vazia\n\n");

return NULL;

}else{

node *ultimo = PILHA->prox,

*penultimo = PILHA;

 

while(ultimo->prox != NULL){

penultimo = ultimo;

ultimo = ultimo->prox;

}

 

penultimo->prox = NULL;

tam--;

return ultimo;

}

}

 

Só precisamos saber uma forma de pegar os dois últimos valores da pilha, para fazer a calculadora funcionar. Desde já, agradeço!

[arfneto]

2 horas atrás, Gustavo Moura Corcovia disse:

Boa noite, estou com meu grupo tentando fazer um cálculo de pilhas em C, porém não estou conseguindo identificar como fazer isso. O calculo consiste em pegar os dois últimos valores da pilha, e escolher a operação que será realizada

 

se a operação é o que está no menu não entendo o que tem a ver com os dois últimos elementos..,

 

Note que a pilha sequer tem esse conceito: a pilha tem 1 elemento (visível), ou nenhum. A cada vez. O primeiro. Na nomenclatura comum de pilha, os dois últimos elementos se obtém rodando TOP() depois POP() e TOP(), em C++ por exemplo.

 

E fica a ambiguidade do que o enunciado chama de último...

 

Não implemente estruturas como essa (containers) como se fossem um nó: sempre vai trabalhar mais para conseguir menos resultado. Uma pilha não é  um nó. Um nó não é uma pilha. O mesmo vale para lista, mapa, conjunto... Mesmo uma pilha, o container main simples de todos, tem metadados: o tamanho, o início...