ME3

#include <stdio.h>
#include <stdlib.h>

typedef struct polynode POLYNODE;
typedef struct poly POLY;
struct polynode
{
    int x;
    int y;
    int z;
    int COEFF;
    POLYNODE* NEXT;

};
struct poly
{
    POLYNODE* l;

};

// 1 means node 1 is greater than node 2
// 0 means node 1 is less than node 2
// 2 means node 1 is equal to node 2 equal

int GREATER(POLYNODE* node1,POLYNODE* node2)
{
    if(node1->x > node2->x)
    {
        return 1;
    }
    else if(node1->x == node2->x)
    {
        if(node1->y > node2->y)
        {
            return 1;
        }
        else if(node1->y == node2->y)
        {
            if(node1->z > node2->z)
            {
                return 1;
            }
            else if(node1->z == node2->z)
            {
                return 2;
            }
            else
            {
                return 0;
            }

        }
        else
        {
            return 0;
        }

    }
    else
    {
        return 0;
    }

}

void ZEROPOLY(POLY* P)
{
    POLYNODE* tau;
    tau = malloc(sizeof(POLYNODE));
    P->l=tau;
    P->l->x = -1;
    P->l->y = -1;
    P->l->z = -1;
    P->l->NEXT = tau;
}

void POLYREAD(POLY* P,int n)
{
    POLYNODE* v;
    POLYNODE* alpha;
    POLYNODE* beta;
    v = malloc(sizeof(POLYNODE));
    int i = 0,ex,ey,ez,coeff;
    ZEROPOLY(P);
    while(i < n)
    {
        v = malloc(sizeof(POLYNODE));
        scanf("%d %d %d %d",&ex,&ey,&ez,&coeff);
        v->x = ex;
        v->y = ey;
        v->z = ez;
        v->COEFF = coeff;
        beta = P->l;
        alpha = beta->NEXT;
        while(GREATER(&alpha,&v) == 1)
        {
            beta = alpha;
            alpha = alpha->NEXT;
        }
        beta->NEXT = v;
        v->NEXT = alpha;
    }
}

void POLYADD(POLY* P, POLY* Q)
{
    POLYNODE* alpha;
    POLYNODE* beta;
    POLYNODE* sigma;
    POLYNODE* tau;
    alpha = P->l->NEXT;
    beta = Q->l->NEXT;
    sigma = Q->l;
    while(1)
    {
        if(GREATER(&alpha,&beta) == 0)
        {
            sigma = beta;
            beta = beta->NEXT;
        }
        else if (GREATER(&alpha,&beta) == 2)
        {
            if(alpha == P->l)
            {
                break;
            }
            beta->COEFF = beta->COEFF + alpha->COEFF;
            if(beta->COEFF == 0)
            {
                tau = beta;
                sigma->NEXT = beta->NEXT;
                beta = beta->NEXT;
                free(tau);
            }
            else
            {
                sigma = beta;
                beta = beta->NEXT;
            }
            alpha = alpha->NEXT;
        }
        else if (GREATER(&alpha,&beta) ==  1)
        {
            tau = malloc(sizeof(POLYNODE));
            tau->COEFF = alpha->COEFF;
            tau->x = alpha->x;
            tau->y = alpha->y;
            tau->z = alpha->z;
            sigma->NEXT = tau;
            tau->NEXT = beta;
            sigma = tau;
            alpha = alpha->NEXT;
        }

    }
}