E aí, galera! Aqui vai um post sobre árvores. Neste problema da nossa P1 era preciso implementar um solução que calculasse o valor de uma expressão aritmética utilizando árvore. Segue o código abaixo!


#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define max 100

typedef struct celula celula;
typedef celula *node;
typedef struct pilha pilha;

struct pilha{
    char caracter[max];
    int t;
};

struct celula{
    char info;
    celula *filhos[max];
};


/**********************************************************************************************************
funcao que aloca a expressao na arvore
**********************************************************************************************************/
node alocar(char expressao[], node *arvore){
    *arvore=(node)malloc(sizeof(celula));
    int aberto=0;
    char dir[max], esq[max];
    bool achou=false;
    for(int i=0; expressao[i]!='\0'; i++){
        if(expressao[i]=='(') aberto++;
        else if(expressao[i]==')') aberto--;
        if(aberto==1 && (expressao[i]=='*' || expressao[i]=='+' || expressao[i]=='-' || expressao[i]=='/')){
            (*arvore)->info=expressao[i];
            (*arvore)->filhos[0]=(*arvore)->filhos[1]=NULL;
            for(int j=1; j<i; j++){
                esq[j-1]=expressao[j];
            }
            esq[i-1]='\0';
            for(int j=i+1; j<(strlen(expressao)); j++){
                dir[j-i-1]=expressao[j];
                dir[j-i]='\0';
            }
            //dir[j]='\0';
            alocar(esq, &(*arvore)->filhos[0]);
            alocar(dir, &(*arvore)->filhos[1]);
            achou=true;
        }
    }
    if(achou==false){
        for(int i=0; expressao[i]!='\0'; i++){
            if(expressao[i]!='(' && expressao[i]!=')')
                (*arvore)->info=expressao[i];
        }
    }
}



/**********************************************************************************************************
funcao que calcula o valor da expressao armazenada na arvore
**********************************************************************************************************/
int calcular(node arvore){
    if(arvore->info>='0' && arvore->info<='9')
        return ((arvore->info)-'0');
    else if(arvore->info=='*' || arvore->info=='+' || arvore->info=='-' || arvore->info=='/'){
        switch(arvore->info){
            case '*': return (calcular(arvore->filhos[0]))*(calcular(arvore->filhos[1]));
            case '-': return (calcular(arvore->filhos[0]))-(calcular(arvore->filhos[1]));
            case '/': return (calcular(arvore->filhos[0]))/(calcular(arvore->filhos[1]));
            case '+': return (calcular(arvore->filhos[0]))+(calcular(arvore->filhos[1]));
        }
    }
    else{
        printf("expressao invalida");
        return 0;
    }
}


int main(){
    int parenteses=0, resultado;
    pilha P;
    char expressao[max];
    node arvore;

    P.t=-1;
    scanf("%[^\n]s", expressao);
    for(int i=0; i<strlen(expressao); i++){
        if(expressao[i]=='('){
            P.t++;
            P.caracter[P.t]='(';
           }
        else if(expressao[i]==')'){
            if(P.t==-1){
                printf("expressao invalida");
                return 0;
            }
            else P.t--;
        }
        else if((expressao[i]<'0' || expressao[i]>'9') && expressao[i]!='+' && expressao[i]!='-' && expressao[i]!='*' && expressao[i]!='/'){
            printf("expressao invalida");
            return 0;
        }
    }
    if(P.t!=-1){
        printf("expressao invalida");
        return 0;
    }
    alocar(expressao, &arvore);
    resultado=calcular(arvore);
    printf("resultado = %d\n", resultado);

    return 0;
}