calc_polonesa.c

#include "pilha.h"
#include "arvore_binaria.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

void manipulacao_arvores(Pilha* nova_pilha, char* string_insercao){//função responsável por manipular as árvores na pilha e fundí-las; a subárvore que contem o operador (arvore_mae)
                           //recebe o topo da pilha como subarvore esquerda; o topo da pilha é removido; a subarvore do novo topo
                           // da pilha é inserida como subárvore direita da arvore_mae;

    printf("entrei em amnipulação arvores\n");
    Arvore_Binaria* arvore_mae = arvore_criar(string_insercao);//arvore_mae contem o nó raiz que armazena o operador;

            Arvore_Binaria* subarvore_esquerda = pilha_topo_arvore(nova_pilha);
            Arvore_Binaria* nova_arvore = arvore_fusao_esquerda(subarvore_esquerda, arvore_mae);

            arvore_apontar_null(subarvore_esquerda);//esta função evita que se perca referência para a subarvore
                                            //direita ou esquerda que foi retirada do topo da pilha e fundida a outra árvore no momento
                                            //em que a memória da subarvore for desalocada;
            pilha_remover(nova_pilha);


            Arvore_Binaria* subarvore_direita = pilha_topo_arvore(nova_pilha);
            nova_arvore = arvore_fusao_direita(subarvore_direita, arvore_mae);
            arvore_apontar_null(subarvore_direita);
            pilha_remover(nova_pilha);

            printf("imprimindo a arvore montada em pré ordem:\n");
            arvore_imprimir(nova_arvore);
            pilha_inserir_arvore(nova_pilha, nova_arvore);

}

int main(){

    char vet_entrada[100];
    fgets(vet_entrada, 100, stdin);

    char** entrada_processada = (char**)malloc(50*sizeof(char*));//cada posição de entrada processada possui uma string que será o item do tad arvore
    for(int i=0; i<50; i++){
        entrada_processada[i] = (char*)malloc(1000 * sizeof(char));
    }

    char* token_atual;

    int i=0;
    token_atual = strtok(vet_entrada, " ");

    while(token_atual != NULL){
       // printf("AQUI token_atual é: %s\n", token_atual);
        strcpy(entrada_processada[i], token_atual);
        //printf("2 entrada processada é: %s\n", entrada_processada[i]);
        i++;
        token_atual = strtok(NULL, " ");
    }

   /* for(int j=0; j < i; j++){ //teste da entrada
        printf("entrada_processada[%d] é: %s-\n", j, entrada_processada[j]);
    }
    */
   Pilha* nova_pilha = pilha_criar();

   for(int j=0; j<i; j++){//inserção das strings na pilha; ocorre o processo de montagem da árvore com a expressão posfixada correspondente;

        if( strcmp(entrada_processada[j], "*") == 0 || strcmp(entrada_processada[j], "-") == 0  || strcmp(entrada_processada[j], "+") == 0  || strcmp(entrada_processada[j], "/") == 0 ){
            char string_insercao[5];
            strcpy(string_insercao, entrada_processada[j]);
            printf("a string_insercao é: %s\n", string_insercao);
            Arvore_Binaria* arv = arvore_criar(string_insercao);
            pilha_inserir_arvore(nova_pilha, arv);

        }
        else{

            char string_insercao[5];
            strcpy(string_insercao, entrada_processada[j]);
            Arvore_Binaria* arv = arvore_criar(string_insercao);
            pilha_inserir_arvore(nova_pilha, arv);
            printf("a string_insercao no else  é: %s\n", string_insercao);
            printf("entrei no else, pilha vazia? %d\n", pilha_vazia(nova_pilha));
            manipulacao_arvores(nova_pilha, string_insercao);

        }
    //explicar o algoritmo
   }


    return 0;
}

//dar free nas strings da entrada
//dar free nos tads
//dar free na árvore que estava na pilha;