Polinomio CriaTermo(float coef, int exps[], int numVars)
{
    Polinomio *r, *p, q;
    r=p;
    if(numVars != -1)
    {
        while (i<numVars-1)
        {
            q=MALLOC(sizeof(Termo));
            q->tipo = tipoPoli;
            q->expo = exps[i];
            q->prox = NULL;
            if(i!=0)
                (*p)->info.poli = q;
            *p = q;
            i++;
        }
    }
    q=MALLOC(sizeof(Termo));
    q->tipo = tipoConst;
    q->info.coef = coef;
    q->expo = exps[i];
    q->prox = NULL;
    if(numVars !=1)
        (*p)->info.poli = q;
    else
        p=q;

    return *r;
}

Polinomio CriaPolinomioNulo()
{
    return NULL;
}

Boolean PolinomioNulo(Polinomio p)
{
    if(p==NULL)
        return true;
    else
        return false;
}

Polinomio CopiaPolinomio(Polinomio p)
{
    if(p==NULL)
        return NULL;

    q=MALLOC(sizeof(Termo));

    if(p->tipo = tipoPoli)
    {
        q->tipo = tipoPoli; //MUITO IMPORTANTE
        q->expo = p->expo;
        q->info.poli = CopiaPolinomio(p->info.poli);
        q->prox = CopiaPolinomio(p->prox);
    }
    else
    {
        q->tipo = tipoConst;
        q->coef = p->coef;
        q->expo = p->expo;
        q->prox = CopiaPolinomio(p->prox);
    }
    return  q;
}


Polinomio SomaPolinomios(Polinomio a, Polinomio b)
{
    Polinomio soma = CriaPolinomioNulo(),s, *p;

    *p = soma;

    while (a!=NULL&& b!=NULL) //percorre os nós da lista sequencialmente
    {
        if (((a->expo)==(b->expo)) || a->expo = 0 || b->expo = 0) //se os termos têm o mesmo grau, eles são somados
        {
            if(a->tipo == tipoConst)
            {
                int x = a->info.coef + b->info.coef;
                int y;
                if(a->expo && b->expo!=0) //trata caso expo = 0
                    y = a->expo;
                else
                    y = a->expo + b->expo;
                if(y!= 0)
                {
                    s = MALLOC(sizeof(Termo));
                    s->tipo = tipoConst;
                    s->info.coef = x;
                    s->expo = y;
                }
                else    //TESTAR //GAMBIARRA?
                    s= NULL;
            }
            else
            {
                Polinomio res = SomaPolinomios(a->info.poli, b->info.poli);
                if(res!=NULL)
                {
                    s = MALLOC(sizeof(Termo));
                    s->tipo = tipoPoli;
                    s->expo = y;
                    s->info.poli = res;
                }
                else
                    s=NULL;
            }
            /*
            if(soma == NULL)
                soma = s;
            else
            {
                soma->prox = s;
                soma = soma->prox;
            }
            */
            InsereApos(soma, s);
            a=a->prox;
            b=b->prox;
        }
        else if(a->expo > b->expo) //se o grau do nó em a é menor que o de b, insere o de a
        {
            s=CopiaTermo(a);
            /*
            if(soma!=NULL)
                soma->prox = s;
            else
                soma = s;
            */
            InsereApos(soma, s);
            //soma = soma->prox;
            a=a->prox;
        }
        else if (b->expo > a->expo ) //se o grau do nó em a é menor que o de b, insere o de b
        {
            s = CopiaTermo(b);
            /*
            if(soma!=NULL)
                soma->prox = s;
            else
                soma = s;
            */
            InsereApos(soma, s);
            //soma = soma->prox;
            b=b->prox;
        }
    }

    //O programa sai do loop quando pelo menos uma dos dois polinomios acaba. Falta inserir os termos restantes do outro, se houverem.

    while (a!=NULL)  //Se a ainda não acabou, continua inserindo seus termos até acabar.
    {
        s = CopiaTermo(a);
        /*
        if(soma!=NULL)
            soma->prox = s;
        else
            soma = s;
        */
        InsereApos(soma, s);
        //soma = soma->prox;
        a=a->prox;
    }

    while (b!=NULL) //Se a ainda não acabou, continua inserindo seus termos até acabar.
    {
        s = CopiaTermo(b);
        /*
        if(soma!=NULL)
            soma->prox = s;
        else
            soma = s;
        */
        InsereApos(soma, s);
       // soma = soma->prox;
        b=b->prox;
    }
    soma->prox = NULL;
    return *p;
} /* SomaPolinomios */


void InsereApos(Polinomio p, Polinomio q)
/*Insere um polinomio @q após o polinômio @p e avança
  até a posição final de @p, se este não é nulo;
  caso contrário, atribui @q a @p */
{
    if(p!=NULL)
    {
      p->prox = q;
      p=p->prox;
    }
    else
        p = q;
}


Polinomio MultPolinomios(Polinomio a, Polinomio b);
/* Devolve o produto dos polinômios 'a' e 'b', sem alterá-los */
{
    Polinomio produto=CriaPolinomioNulo(), prod;
    while (q!=NULL)
    {
        while(p!=NULL)
        {
            prod = MALLOC(sizeof(Termo));
            prod->expo = p->expo + q->expo;
            prod->prox = NULL;
            if(p->tipo == tipoPoli)
            {
                prod->tipo = tipoPoli;
                prod->info.poli = MultPolinomios(p->info.poli, q->info.poli);
            }
            else
            {
                prod->tipo = tipoConst;
                prod->info.coef = (p->coef)*(q->coef);
            }
            produto=SomaPolinomios(produto, prod);  //ver questão dos auxiliares e da liberação de memoria
            p=p->prox;
        }
        q=q->prox;
    }
    return produto;
}