polynomial indeterminate

#define OVERFLOW -2
typedef struct {
   float  coef;       
   int    expn;       
} ElemType, Term;   

typedef struct {
   Term  *term;       
   int    termNum;    
} PolyStruct, *Poly;  

Poly allocPoly(int m) {  
   Poly Q;
   if (!(Q = (Poly)malloc(sizeof(*Q)))) exit(OVERFLOW);  
   if (!(Q->term = (Term*)malloc(m*sizeof(Term))))  
      exit(OVERFLOW);   
   return Q;            
}

Poly FreePoly(Poly P) {
   if (P) { free(P->term);   free(P); }
   return NULL;
}

Poly CreatePoly(Term ts[], int m) {  
   Poly P = allocPoly(m);   
   for (int i=0; i<m; i++) P->term[i] = ts[i];  
   P->termNum = m;   
   return P;
}
void PrintfPoly(Poly P) {  
   for (int i=0; i<P->termNum; i++) {             
      if (i==0) printf("%.2f", P->term[i].coef);  
      else {                                      
         if (P->term[i].coef>0.0) printf(" + ");
         else printf(" - ");
         printf("%.2f", fabs(P->term[i].coef));  
      } 
      if (P->term[i].expn>=1) printf("x");
      if (P->term[i].expn>1) printf("^%d", P->term[i].expn);  
   }
   printf("\n");
} 

int Compare(int a, int b) {  
  if (a < b) return -1;
  if (a > b) return  1;
  return 0;
}

Poly AddPolyP(Poly pa, Poly pb) {
    int i,j,k,pam,pbn;   
    float c;
    Term *pati, *pbtj, *pctk, *patm, *pbtn;
    
    pam = pa->termNum;   pbn = pb->termNum;
    
    Poly pc = allocPoly(pam + pbn);
    
    pati = pa->term;   patm = pati + pam;
    pbtj = pb->term;   pbtn = pbtj + pbn;  
    pctk = pc->term;   k = 0; 
    while (pati < patm && pbtj < pbtn) {
        switch (Compare(pati->expn, pbtj->expn)) {
            case -1: *pctk++ = *pati++;  k++;  break;
            case  1: *pctk++ = *pbtj++;  k++;  break; 
            case  0: c = pati->coef + pbtj->coef; 
                 if (c!=0) { 
                   pctk->expn = pati->expn;   pctk->coef = c;
                   pctk++;   k++;
                   }
                   pati++;   pbtj++;
        }
    }
    
    if (pati == patm) {
       j = pbtn-pbtj;   k += j;
       memcpy(pctk, pbtj, j*sizeof(Term));
       k += pbtn-pbtj;
    }
    
    if (pbtj == pbtn) {
        i = patm-pati;   k += i;
         memcpy(pctk, pati, i*sizeof(Term));

    }
    
    if (k < pam+pbn) {
         if (!(pc->term = (Term*)realloc(pc->term, k*sizeof(Term)))) return NULL;

    }
    
    pc->termNum = k;
    
    return pc;   
}


Poly AddPoly(Poly pa, Poly pb) {
   Poly pc;   int i=0, j=0, k=0;   float c;
   int pam = pa->termNum, pbn = pb->termNum;
   if (!(pc = allocPoly(pam+pbn))) return NULL;
   while (i < pam && j < pbn) {
      switch (Compare(pa->term[i].expn, pb->term[j].expn)) {
        case -1: pc->term[k++] = pa->term[i++];  break;
        case  1: pc->term[k++] = pb->term[j++];  break;
        case  0: c = pa->term[i].coef + pb->term[j].coef; 
            if (c!=0) {
               pc->term[k].expn = pa->term[i].expn;
               pc->term[k].coef = c;
               k++;
            }
             i++;   j++;   
       }
   
   }
   
   if (i == pam) {
        memcpy(pc->term+k, pb->term+j, (pbn-j)*sizeof(Term));   
        k += pbn-j;
   }
    if (j == pbn) {
        memcpy(pc->term+k, pa->term+i, (pam-i)*sizeof(Term));   
        k += pam-i; 
    }
    
    if (k < pam + pbn) {
       if (NULL == (pc->term = (Term*)realloc(pc->term, k*sizeof(Term)))) return NULL;
    }
    
    pc->termNum = k;
    
     return pc;  
}