PROJETO: Algoritmo de Transformar expressão de pós-fixa para pré-fixa - Estrutura de Dados

PROJETO: Algoritmo de Transformar expressão de pós-fixa para pré-fixa - Estrutura de Dados

Algoritmo de Transformar expressãod e pós-fixa para pré-fixa - Estrutura de Dados:



arquivos estão antes de cada página de código:


===========================
main.c
===========================
/*  Algoritmo de Transformar expressãod e pós-fixa para pré-fixa - Estrutura de Dados
    | Kássio Rômulo Lima SOusa CP09126-81 | Núbia Cristine Silveira dos Santos CP09142-81 |
*/

#define TRUE 1
#define FALSE 0

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
#include<math.h>
 
#include "stack.h"
 
/* Função para calculos básicos, adição, subtração, multiplicação e divisão */
int calc(int op1, int op2, char opcao){
    int aux=0;

    if(opcao == '+'){
        aux = op1 + op2;
    }
    if(opcao == '-'){
        aux = op1 - op2;
    }
    if(opcao == '*'){
        aux = op1 * op2;
    }
    if(opcao == '/'){
        aux = op1 / op2;
    }
    if(opcao == '^'){
        aux = pow((float)op1,(float)op2);
    }
    return aux;
}

/* Funcao para avaliar a expressao posfixa e fazer todas as possibilidades */
void transforma(){
     int i=0;
     int op1, op2, resultado, valor, elemento;
     char expressao[60], *aux;
     stack *form;
  
   printf("Digite uma expressão pos-fixa: ");
   scanf("%s", expressao);
   form = stkCreate(strlen(expressao));
  
   while(i < strlen(expressao)){
       aux = expressao[i];
       if((expressao[i] == '+') ||  (expressao[i] == '-') || (expressao[i] == '*') || (expressao[i] == '/') ||(expressao[i] == '^') ){

           op1 = (int) stkpop(form);
           op2 = (int) stkpop(form);

           valor = calc(op1, op2, aux);
           stkpush(form, (void*)valor);                                    
      }else{                
           elemento = atoi(&aux);
           stkpush(form, (void*) elemento);                 
      }
   i++;
   }
   resultado = (int)stkpop(form);
   printf("Resultado da operacao = %d\n", resultado);
   free(form);  
}
int main(void){
  transforma();
  system("pause"); 
}

===========================
stack.c
===========================
/*  Algoritmo de Transformar expressãod e pós-fixa para pré-fixa - Estrutura de Dados
    | Kássio Rômulo Lima SOusa CP09126-81 | Núbia Cristine Silveira dos Santos CP09142-81 |
*/

#define _STACK_H_

#define TRUE 1
#define FALSE 0

#include <stdio.h>
#include <assert.h>
#include "stack.h"

/* Funcao Criar pilha */
stack *stkCreate(int max){
      stack *s;
            if(max>0){
            s = (stack *) malloc(sizeof(stack));
              if(s!=NULL){
                 s->item = (void **) malloc(max*sizeof(void *));           
                   if(s->item!=NULL){
                      s->maxitens = max;
                      s->topo = -1;
                      return s;
                  }
                  free(s);
              }         
            }
      return NULL;
}

/* Funcao para Destruir pilha */
int stkdestroy(stack *s){
       if(s!=NULL){
          free(s->item);
          free(s);
          return TRUE;           
       }
    return FALSE;
}

/* Funcao para Inserir elemento na pilha */
int stkpush(stack *s, void *item){
    if(s!=NULL){
      if(s->topo < s->maxitens-1){
        s->topo++;
        s->item[s->topo] = item;
        return TRUE;        
        }
    }
    return FALSE;
}

/* Funcao que Remove elemento da pilha */
void *stkpop(stack *s){
     void *aux;
     if(s!=NULL){
       if(s->topo > -1){
         aux = s->item[s->topo];
         s->topo--;
         return aux;
         }
       }
     return NULL;
}

/* Funcao que Retorna o elemento do topo da pilha */
void *stktop(stack *s){
     if(s!=NULL){
        if(s->topo > -1){
           return s->item[s->topo];
        }
     }
return NULL;
}

/* Funcao que Confere se a pilha está vazia*/
int stkisempty(stack *s){
    if(s!=NULL){
      if(s->topo < 0){
        return TRUE;
        }
      }
    return FALSE;
}

/* Fim das funções */
===========================
stack.h
===========================
/*Folha de protótipos das funções utilizadas no programa*/

#ifndef __STACK_H_
#define __STACK_H_

/* Estrutura stack */
typedef struct _stack_{
        int maxitens;
        int topo;
        void ** item;
}stack;

/*Funcao Para criar a pilha:
pré-condições: ; maxItens > 0 ; retorna a pilha
               ; retorna null em caso de maxitens> 0 ou nao houver espaço para alocar
*/

stack *stkCreate(int max);

/*Funcao para Destruir pilha:
pré-condições: ; S nao ser null ;retorna TRUE se a pilha for eliminada
               ; retorna FALSE caso nao satisfaça as pré-condições
*/

int stkdestroy(stack *s);

/*Funcao que Insere elemento da pilha:
pré-condições: ; s nao ser null e s->topo tem que ser menor que s->maxitens-1
               ; retorna TRUE se o elemento for inserido
*/

int stkpush(stack *s, void *item);

/*Funcao que Remove elemento da pilha:
pré-condições: ; c nao ser null e c->item nao pode ser null
               ; retorna o elemento se o elemento for removido
               ; retorna NULL caso nao satisfaça as pré-condições
*/

void *stkpop(stack *s);

/*Funcao que Retorna elemento do topo:
pré-condições: ; s nao ser null e s->topo te que ser maior que -1
               ; retorna elemento do topo
*/

void *stktop(stack *s);

/*Funcao que Confere se a pilha está vazia:
pré-condições: ; s nao ser null e s->topo te que ser menor que 0
               ; retorna TRUE se pilha for vazia
               ; retorna FALSE se pilha nao for vazia
*/
 
int stkisempty(stack *s);

#endif