l4p1-SDA

#include"l4p1.h"

int main()
{
    char exp[MAXN];
    cout<<"Dati expresia ";
    cin>>expr;
    char*pf=infix2Postfix(expr);
    cout<<"val"<<expr<<"="<<eval(pf)<<endl;
    delete[]pf;
    pf=0;

    return 0;

}

/c

#include"l4p1.h"

//stiva
void initStack(Stiva &S)
{
    S=0;
}

int isEmpty(Stiva S)
{
    return !S;
}

Atom top(Stiva S)
{
    assert(S);
    return S->data;
}

void push(Stiva &S, Atom a)
{
    PNod p=new Nod;
    assert(p);
    p->data=a;
    p->Succ=S;
    S=p;
}

Atom pop(Stiva &S)
{
    assert(s);
    PNod p=S;
    S=S->Succ;
    Atom a=p->data;
    delete p;
    return a;
}

int pos(char c)
{
    switch(c)
    {
    case '+':case '-' return 1;
    case '*':case '/' return 2;
    case '^': return 3;
    case '(': return 0;
    case '#': return -1;
    }
}

char* infix2Postfix(char exp[])
{
    char buffer[MAXN],*rez;
    StivaC(sopt=0;push(s,'#');  //sopt StivaOperatori
    int i,j=0;
    char C;
    for(i=0;expr[i];i++)
        if (isdigit(exp[i]))
        {
            buffer[j++]=expr[i];
        }
        else if(expr[i]==')')
            while(top((sopt)!='(')
            {
                buffer[j++]=popC(sopt);
                c=popC(sopt);
            }
        else
            while(pos(topS(sopt))>=poe(exp[i]))
                buffer[j++]=popC(sopt);
        pushC(sopt,exp[i]);
        while(topC(sopt)!='#')
            buffer[j++]=popC(sopt);
            c=popC(sopt);
            buffer[j++]='\0';
            rez=new char[j];
            assert(rez);
            strcpy(rez,buffer);
                return rez;
}

double eval(char *pf)
{
    double rez,a,b;
    StivaD s=0;
    int i;
    for(i=0;pf[i];i++)
        if(isdigit(pf[i]))
            pushD(s,pf[i]-'0');
        else
        {
            b=popD(s);
            a=popD(s);
            switch(pf[i])
            {
                case '+' pushD(s,a+b);
                    break;
                case '-' pushD(s,a-b);
                    break;
                case '*' pushD(s,a*b);
                    break;
                case '/' pushD(s,a/b);
                    break;
                case '^' pushD(s,pow(a,b));
                    break;
            }
        }
        assert(s);
        rez=popD(s);
        assert(!s);
        return rez;
}



//coada

void initQueque(Coada &C)
{
    C.prom=C.ultim=0;
}

int isEmpty(Coada C)
{
    return !C.prim;
}

Atom front(Coada C)
{
    assert(C.prim);
    return C.prim->data;
}

void put(Coada &C,Atom a)
{
    PNod p=new Nod;
    assert(p);
    p->data=a;
    p->Succ=0;

    if(isEmpty(c))
        C.prim=p;
    else
        C.ultim=p;
}

Atom get(Coada &C)
{
    assert(C.prim);
    PNod p=C.prim;
    C.prim=p->Succ;

    if(!C.prim)
        C.ultim=0;
    Atom a=p->data;
    delete p;
    return a;
}

/h
#ifndef                     L4P1_H
#define                     L4P1_H
#pragma once
#define MAXN 1000

#include<iostream>
#include<assert.h>
#include<ctype.h>
#include<string.h>
#include<math.h>


//stiva
typedef char Atom;
typedef struct Nod{
    Atom data;
    Nod Succ;
}*PNod;
typedef PNod Stiva;
//coada
typedef Struct{
    PNod prim,ultim;
}Coada;
//stiva
void initStack(Stiva &S);
int isEmpty(Stiva S);
Atom top(Stiva S);
void push(Stiva &S, Atom a);
Atom pop(Stiva &S);
int pos(char c);
double eval(char *pf);
char* infix2Postfix(char exp[]);

//coada
void initQueque(Coada &C);
int isEmpty(Coada C);
Atom front(Coada C);
void put(Coada &C,Atom a);
Atom get(Coada &C);



#endif