void posfijo(char *colaE,pila_tipo_dato *pilaOP, char *numactual,int fin_linea ){
char oper='\0'; //auxiliar
int Boolinsert=0;
char sep='#';
if (esOperador(numactual)==0){ //quiere decir que es operando o numero
if (fin_linea==1){ //simbolo terminal
while(pilaOP->cant_element!=0){
char quitar;
pila_desapilar(pilaOP,&quitar);
strcat(colaE,&quitar);
}
}
else{
strcat(colaE,numactual);
strcat(colaE,&sep);
}
}
if(esOperador(numactual)==1)
{
//3.1) Si la pila esta vacía o el operador tiene mayor prioridad
//que el que está en la cima de la pila (o bien es la máxima prioridad),
//se mete en la pila.
if (pilaOP->cant_element>0){
pila_getfrente(pilaOP,&oper);
if (precedencia(numactual)>precedencia(&oper)){
pila_apilar(pilaOP,numactual);
Boolinsert=1;
}
}
if (pilaOP->cant_element==0){
pila_apilar(pilaOP,numactual);
Boolinsert=1;
}
//3.2) Si la prioridad es menor o igual, el operador se saca de la pila,
//se mete en la expresión postfija y se vuelve a hacer la comparación con
//el nuevo elemento de la cima de la pila.
if(Boolinsert==0 && pilaOP->cant_element>0)
{
pila_getfrente(pilaOP,&oper);
while(precedencia(numactual)<=precedencia(&oper)&& pilaOP->cant_element>0 ){
char quitar;
pila_desapilar(pilaOP,&quitar);
strcat(colaE,&quitar);
pila_getfrente(pilaOP,&oper);
}
pila_apilar(pilaOP,numactual);
}
}
}
int main(){
int n;
Stack s;
s=empty();
char c;
char posfija[100];
int largo=0;
int flag=0;
// Se pasa a posfija
while(1){
if(!flag) scanf("%c",&c);
else flag=0;
if(c=='\n' || c=='\0') break;
if(c=='('||c=='{'||c=='[') s=push(c,s);
else if(c==')' || c=='}' || c==']'){
char a=top(s);
while(a!='(' && a!='{' && a!='['){
posfija[largo++]=a;
s=pop(s); a=top(s);
}
s=pop(s);
}
else if(esOperando(c)==1){
posfija[largo++]=c;
scanf("%c",&c);
while(esOperando(c)){
if(c=='\n' || c=='\0'){
flag=1;
break;
}
posfija[largo++]=c;
scanf("%c",&c);
}
posfija[largo++]=',';
flag=1;
continue;
}
else if(esOperador(c)){
while(!isEmpty(s) && (prec(top(s))>= prec(c))){
posfija[largo++]=top(s);
s=pop(s);
}
s=push(c,s);
}
}
while(!isEmpty(s)){
posfija[largo++]=top(s);
s=pop(s);
}
// Se termina la conversion
printf("%.2lf\n",evaluar(posfija, largo));
return 0;
}
void verificarExpresion(char** cad){
String cadena = *cad;
int length = strlen(cadena);
/** Auxiliares para continuar con el ciclo*/
int i = 0;
StackEntry op1, op2, res;
int posError;
bool evalacion = true;
/** Pila para el evaluador */
ptrNodoPila pila = NULL;
while(cadena[i] != '\0' && evalacion == true){
/** Validamos si se trata de un operando */
if(esOperando(cadena[i])){
int aux = cadena[i] -'0';
push(&pila,aux);
}
else /**Validamos si es un operador */
if (esOperador(cadena[i])){
/** Valida si existen al menos dos operandos */
if(!stackEmpty(&pila)){
op2 = pop(&pila);
if (!stackEmpty(&pila)){
op1 = pop(&pila);
res = calcular(op1, cadena[i], op2);
push(&pila,res);
}else{
printf("\nSe esperaba un operando antes del operador %c en lo posicion %d\n",cadena[i],i+1);
break;
}
}else{
printf("\nSe esperaban dos operandos antes del operador %c en lo posicion %d\n",cadena[i],i+1);
break;
}
}else{
printf("Caracter invalido en la posicion %d\n",i+1);
break;
}
/** Valida que haya quedado solo un numero en la pila */
i++;
}
if(!stackEmpty(&pila)){
res = pop (&pila);
if(stackEmpty(&pila))
printf("\n<<< Expresion posfija valida!>>>\n<<< Resultado final:\t%d>>>\n",res);
else
printf("\n>>> Se esperaban mas operadores\n");
}
}
void ejecutar(pila_tipo_dato *pilaPos, char *res ){
pila_tipo_dato auxresult;
pila_init(&auxresult);
int error=0;
char elemento[TAM_RES],result1[TAM_RES],result2[TAM_RES],resultOp[TAM_RES];
while(pilaPos->cant_element!=0)
{
//ceramos los vectores
init_array(result1,TAM_RES);
init_array(result2,TAM_RES);
init_array(elemento,TAM_RES);
init_array(resultOp,TAM_RES);
pila_desapilar(pilaPos,elemento);
//vemos si es operador
if (esOperador(elemento)==1)
{
if ((auxresult.cant_element)<2){
res[0]=elemento[0];
strcat(res,"Error!!");
pilaPos->cant_element=0;
error=1;
//ocurrio un error
}
pila_desapilar(&auxresult,result1);
pila_desapilar(&auxresult,result2);
operar(result1, result2,elemento[0],resultOp);
pila_apilar(&auxresult,resultOp);
if(error==0){pila_getfrente(&auxresult,res);}
}
else{
pila_apilar(&auxresult,elemento);
}
}
}
void convertirExpresion(char **cad){
String cadena = *cad;
String cPosfija = (String*) malloc(sizeof(String));; //Cadena donde se insertara la expresion convertida
cPosfija = (String *) malloc(sizeof(String));
/** Pilas para los delimitadores*/
ptrNodoPila pilaExpresion = NULL;
int i = 0;
while(cadena[i] != '\0'){
if (esOperando(cadena[i]))
push(&pilaExpresion,cadena[i]);
else
if(esOperador(cadena[i])){
if (stackEmpty(pila))
{
/* code */
}
}
i++;
}
}
int esOperando(char c){
return esOperador(c)==0;
}
nodo *infijaPosfija(char expresion[])
{
nodo *pila,*posfija;
int longitudExpresion, i;
char valor;
pila = crearLista(pila); //inicilar la pila con la funcion//
posfija = crearLista(posfija); // inicializar
longitudExpresion = strlen(expresion); // se necesita para ir recorriendo la lista 1 en 1 (longitud);
for(i = 0; i<longitudExpresion; i++)
{
if (((expresion[i]>=48) && (expresion[i]<=57)) ||((expresion[i]>=65) && (expresion[i]<=90)) || ((expresion[i]>=97) && (expresion[i]<=122)))
posfija =insertarNodoFinal(expresion[i],posfija);
else
{
if (expresion[i]== '(')
pila = push(expresion[i], pila);
else
{
if(esOperador(expresion[i]))
{
if(pila == NULL)
pila = push(expresion[i],pila);
else
{
while(pila!=NULL)
{
if((prioridad (pila->simbolo)>= prioridad(expresion[i])))
{
pila =pop(&valor, pila);
posfija = insertarNodoFinal(valor, posfija);
}
else
break;
}
pila = push(expresion[i],pila);
}
}
}
}
if(expresion[i]== ')')
{
while((pila->simbolo!= '(') &&(pila!=NULL))
{
pila= pop(&valor,pila);
posfija = insertarNodoFinal(valor,posfija);
}
pila =pop(&valor,pila);
}
}
while(pila!=NULL)
{
pila =pop(&valor, pila);
posfija=insertarNodoFinal(valor,posfija);
}
return posfija;
}